fuel_core_client/client/schema/
tx.rs

1use crate::client::{
2    PageDirection,
3    PaginatedResult,
4    PaginationRequest,
5    schema::{
6        Address,
7        AssetId,
8        ConnectionArgsFields,
9        ConversionError,
10        HexString,
11        PageInfo,
12        Tai64Timestamp,
13        TransactionId,
14        TxPointer,
15        U16,
16        U32,
17        U64,
18        UtxoId,
19        coins::ExcludeInput,
20        schema,
21        tx::{
22            transparent_receipt::Receipt,
23            transparent_tx::Output,
24        },
25    },
26    types::TransactionResponse,
27};
28use fuel_core_types::{
29    fuel_tx,
30    fuel_types::{
31        Bytes32,
32        canonical::Deserialize,
33    },
34    fuel_vm,
35    services::executor::{
36        TransactionExecutionResult,
37        TransactionExecutionStatus,
38    },
39};
40use std::{
41    convert::{
42        TryFrom,
43        TryInto,
44    },
45    sync::Arc,
46};
47
48pub mod transparent_receipt;
49pub mod transparent_tx;
50
51#[derive(cynic::QueryVariables, Debug, Clone)]
52pub struct TxIdArgs {
53    pub id: TransactionId,
54}
55
56/// Retrieves the transaction in opaque form
57#[derive(cynic::QueryFragment, Clone, Debug)]
58#[cynic(
59    schema_path = "./assets/schema.sdl",
60    graphql_type = "Query",
61    variables = "TxIdArgs"
62)]
63pub struct TransactionQuery {
64    #[arguments(id: $id)]
65    pub transaction: Option<OpaqueTransactionWithStatus>,
66}
67
68/// Retrieves the transaction in opaque form
69#[derive(cynic::QueryFragment, Clone, Debug)]
70#[cynic(
71    schema_path = "./assets/schema.sdl",
72    graphql_type = "Query",
73    variables = "TxIdArgs"
74)]
75pub struct TransactionStatusQuery {
76    #[arguments(id: $id)]
77    pub transaction: Option<OpaqueTransactionStatus>,
78}
79
80#[derive(cynic::QueryFragment, Clone, Debug)]
81#[cynic(
82    schema_path = "./assets/schema.sdl",
83    graphql_type = "Query",
84    variables = "ConnectionArgs"
85)]
86pub struct TransactionsQuery {
87    #[arguments(after: $after, before: $before, first: $first, last: $last)]
88    pub transactions: TransactionConnection,
89}
90
91#[derive(cynic::QueryFragment, Clone, Debug)]
92#[cynic(schema_path = "./assets/schema.sdl")]
93pub struct TransactionConnection {
94    pub edges: Vec<TransactionEdge>,
95    pub page_info: PageInfo,
96}
97
98impl TryFrom<TransactionConnection> for PaginatedResult<TransactionResponse, String> {
99    type Error = ConversionError;
100
101    fn try_from(conn: TransactionConnection) -> Result<Self, Self::Error> {
102        let results: Result<Vec<TransactionResponse>, Self::Error> =
103            conn.edges.into_iter().map(|e| e.node.try_into()).collect();
104
105        Ok(PaginatedResult {
106            cursor: conn.page_info.end_cursor,
107            has_next_page: conn.page_info.has_next_page,
108            has_previous_page: conn.page_info.has_previous_page,
109            results: results?,
110        })
111    }
112}
113
114#[derive(cynic::QueryFragment, Clone, Debug)]
115#[cynic(schema_path = "./assets/schema.sdl")]
116pub struct TransactionEdge {
117    pub cursor: String,
118    pub node: OpaqueTransactionWithStatus,
119}
120
121#[derive(cynic::QueryFragment, Clone, Debug)]
122#[cynic(graphql_type = "Transaction", schema_path = "./assets/schema.sdl")]
123pub struct OpaqueTransaction {
124    pub raw_payload: HexString,
125}
126
127#[derive(cynic::QueryFragment, Clone, Debug)]
128#[cynic(graphql_type = "Transaction", schema_path = "./assets/schema.sdl")]
129pub struct OpaqueTransactionWithStatus {
130    pub raw_payload: HexString,
131    pub status: Option<TransactionStatus>,
132}
133
134#[derive(cynic::QueryFragment, Clone, Debug)]
135#[cynic(graphql_type = "Transaction", schema_path = "./assets/schema.sdl")]
136pub struct OpaqueTransactionStatus {
137    pub status: Option<TransactionStatus>,
138}
139
140impl TryFrom<OpaqueTransaction> for fuel_tx::Transaction {
141    type Error = ConversionError;
142
143    fn try_from(value: OpaqueTransaction) -> Result<Self, Self::Error> {
144        let bytes = value.raw_payload.0.0;
145        fuel_tx::Transaction::from_bytes(bytes.as_slice())
146            .map_err(ConversionError::TransactionFromBytesError)
147    }
148}
149
150#[derive(cynic::QueryFragment, Clone, Debug)]
151#[cynic(schema_path = "./assets/schema.sdl", graphql_type = "Transaction")]
152pub struct TransactionIdFragment {
153    pub id: TransactionId,
154}
155
156#[derive(cynic::Enum, Copy, Clone, Debug)]
157#[cynic(schema_path = "./assets/schema.sdl")]
158pub enum ReturnType {
159    Return,
160    ReturnData,
161    Revert,
162}
163
164#[derive(cynic::QueryFragment, Clone, Debug)]
165#[cynic(graphql_type = "ProgramState", schema_path = "./assets/schema.sdl")]
166pub struct ProgramState {
167    pub return_type: ReturnType,
168    pub data: HexString,
169}
170
171impl TryFrom<ProgramState> for fuel_vm::ProgramState {
172    type Error = ConversionError;
173
174    fn try_from(state: ProgramState) -> Result<Self, Self::Error> {
175        Ok(match state.return_type {
176            ReturnType::Return => fuel_vm::ProgramState::Return({
177                let b = state.data.0.0;
178                let b: [u8; 8] =
179                    b.try_into().map_err(|_| ConversionError::BytesLength)?;
180                u64::from_be_bytes(b)
181            }),
182            ReturnType::ReturnData => fuel_vm::ProgramState::ReturnData({
183                Bytes32::try_from(state.data.0.0.as_slice())?
184            }),
185            ReturnType::Revert => fuel_vm::ProgramState::Revert({
186                let b = state.data.0.0;
187                let b: [u8; 8] =
188                    b.try_into().map_err(|_| ConversionError::BytesLength)?;
189                u64::from_be_bytes(b)
190            }),
191        })
192    }
193}
194
195#[allow(clippy::enum_variant_names)]
196#[derive(cynic::InlineFragments, Clone, Debug)]
197#[cynic(schema_path = "./assets/schema.sdl")]
198pub enum TransactionStatus {
199    SubmittedStatus(SubmittedStatus),
200    SuccessStatus(SuccessStatus),
201    PreconfirmationSuccessStatus(PreconfirmationSuccessStatus),
202    SqueezedOutStatus(SqueezedOutStatus),
203    FailureStatus(FailureStatus),
204    PreconfirmationFailureStatus(PreconfirmationFailureStatus),
205    #[cynic(fallback)]
206    Unknown,
207}
208
209#[allow(clippy::enum_variant_names)]
210#[derive(cynic::InlineFragments, Clone, Debug)]
211#[cynic(
212    schema_path = "./assets/schema.sdl",
213    graphql_type = "TransactionStatus"
214)]
215pub enum StatusWithTransaction {
216    SubmittedStatus(SubmittedStatus),
217    SuccessStatus(SuccessStatusWithTransaction),
218    PreconfirmationSuccessStatus(PreconfirmationSuccessStatusWithTransaction),
219    SqueezedOutStatus(SqueezedOutStatus),
220    FailureStatus(FailureStatusWithTransaction),
221    PreconfirmationFailureStatus(PreconfirmationFailureStatusWithTransaction),
222    #[cynic(fallback)]
223    Unknown,
224}
225
226#[derive(cynic::QueryFragment, Clone, Debug)]
227#[cynic(schema_path = "./assets/schema.sdl")]
228pub struct SubmittedStatus {
229    pub time: Tai64Timestamp,
230}
231
232#[derive(cynic::QueryFragment, Clone, Debug)]
233#[cynic(schema_path = "./assets/schema.sdl")]
234pub struct SuccessStatus {
235    pub block_height: U32,
236    pub time: Tai64Timestamp,
237    pub program_state: Option<ProgramState>,
238    pub receipts: Vec<Receipt>,
239    pub total_gas: U64,
240    pub total_fee: U64,
241}
242
243#[derive(cynic::QueryFragment, Clone, Debug)]
244#[cynic(schema_path = "./assets/schema.sdl", graphql_type = "SuccessStatus")]
245pub struct SuccessStatusWithTransaction {
246    pub transaction: OpaqueTransaction,
247    pub block_height: U32,
248    pub time: Tai64Timestamp,
249    pub program_state: Option<ProgramState>,
250    pub receipts: Vec<Receipt>,
251    pub total_gas: U64,
252    pub total_fee: U64,
253}
254
255#[derive(cynic::QueryFragment, Clone, Debug)]
256#[cynic(schema_path = "./assets/schema.sdl")]
257pub struct ResolvedOutput {
258    pub utxo_id: UtxoId,
259    pub output: Output,
260}
261
262#[derive(cynic::QueryFragment, Clone, Debug)]
263#[cynic(schema_path = "./assets/schema.sdl")]
264pub struct PreconfirmationSuccessStatus {
265    pub tx_pointer: TxPointer,
266    pub transaction_id: TransactionId,
267    pub total_fee: U64,
268    pub total_gas: U64,
269    pub receipts: Option<Vec<Receipt>>,
270    pub resolved_outputs: Option<Vec<ResolvedOutput>>,
271}
272
273#[derive(cynic::QueryFragment, Clone, Debug)]
274#[cynic(
275    schema_path = "./assets/schema.sdl",
276    graphql_type = "PreconfirmationSuccessStatus"
277)]
278pub struct PreconfirmationSuccessStatusWithTransaction {
279    pub tx_pointer: TxPointer,
280    pub transaction_id: TransactionId,
281    pub total_fee: U64,
282    pub total_gas: U64,
283    pub transaction: Option<OpaqueTransaction>,
284    pub receipts: Option<Vec<Receipt>>,
285    pub resolved_outputs: Option<Vec<ResolvedOutput>>,
286}
287
288#[derive(cynic::QueryFragment, Clone, Debug)]
289#[cynic(schema_path = "./assets/schema.sdl")]
290pub struct FailureStatus {
291    pub block_height: U32,
292    pub time: Tai64Timestamp,
293    pub reason: String,
294    pub program_state: Option<ProgramState>,
295    pub receipts: Vec<Receipt>,
296    pub total_gas: U64,
297    pub total_fee: U64,
298}
299
300#[derive(cynic::QueryFragment, Clone, Debug)]
301#[cynic(schema_path = "./assets/schema.sdl", graphql_type = "FailureStatus")]
302pub struct FailureStatusWithTransaction {
303    pub transaction: OpaqueTransaction,
304    pub block_height: U32,
305    pub time: Tai64Timestamp,
306    pub reason: String,
307    pub program_state: Option<ProgramState>,
308    pub receipts: Vec<Receipt>,
309    pub total_gas: U64,
310    pub total_fee: U64,
311}
312
313#[derive(cynic::QueryFragment, Clone, Debug)]
314#[cynic(schema_path = "./assets/schema.sdl")]
315pub struct PreconfirmationFailureStatus {
316    pub tx_pointer: TxPointer,
317    pub transaction_id: TransactionId,
318    pub total_fee: U64,
319    pub total_gas: U64,
320    pub receipts: Option<Vec<Receipt>>,
321    pub resolved_outputs: Option<Vec<ResolvedOutput>>,
322    pub reason: String,
323}
324
325#[derive(cynic::QueryFragment, Clone, Debug)]
326#[cynic(
327    schema_path = "./assets/schema.sdl",
328    graphql_type = "PreconfirmationFailureStatus"
329)]
330pub struct PreconfirmationFailureStatusWithTransaction {
331    pub tx_pointer: TxPointer,
332    pub transaction_id: TransactionId,
333    pub total_fee: U64,
334    pub total_gas: U64,
335    pub transaction: Option<OpaqueTransaction>,
336    pub receipts: Option<Vec<Receipt>>,
337    pub resolved_outputs: Option<Vec<ResolvedOutput>>,
338    pub reason: String,
339}
340
341#[derive(cynic::QueryFragment, Clone, Debug)]
342#[cynic(schema_path = "./assets/schema.sdl")]
343pub struct SqueezedOutStatus {
344    pub reason: String,
345}
346
347#[allow(clippy::enum_variant_names)]
348#[derive(cynic::InlineFragments, Clone, Debug)]
349#[cynic(schema_path = "./assets/schema.sdl")]
350pub enum DryRunTransactionStatus {
351    SuccessStatus(DryRunSuccessStatus),
352    FailureStatus(DryRunFailureStatus),
353    #[cynic(fallback)]
354    Unknown,
355}
356
357impl TryFrom<DryRunTransactionStatus> for TransactionExecutionResult {
358    type Error = ConversionError;
359
360    fn try_from(status: DryRunTransactionStatus) -> Result<Self, Self::Error> {
361        Ok(match status {
362            DryRunTransactionStatus::SuccessStatus(s) => {
363                let receipts = s
364                    .receipts
365                    .into_iter()
366                    .map(|receipt| receipt.try_into())
367                    .collect::<Result<Vec<fuel_tx::Receipt>, _>>()?;
368                TransactionExecutionResult::Success {
369                    result: s.program_state.map(TryInto::try_into).transpose()?,
370                    receipts: Arc::new(receipts),
371                    total_gas: s.total_gas.0,
372                    total_fee: s.total_fee.0,
373                }
374            }
375            DryRunTransactionStatus::FailureStatus(s) => {
376                let receipts = s
377                    .receipts
378                    .into_iter()
379                    .map(|receipt| receipt.try_into())
380                    .collect::<Result<Vec<fuel_tx::Receipt>, _>>()?;
381                TransactionExecutionResult::Failed {
382                    result: s.program_state.map(TryInto::try_into).transpose()?,
383                    receipts: Arc::new(receipts),
384                    total_gas: s.total_gas.0,
385                    total_fee: s.total_fee.0,
386                }
387            }
388            DryRunTransactionStatus::Unknown => {
389                return Err(Self::Error::UnknownVariant("DryRunTxStatus"))
390            }
391        })
392    }
393}
394
395#[derive(cynic::QueryFragment, Clone, Debug)]
396#[cynic(schema_path = "./assets/schema.sdl")]
397pub struct DryRunSuccessStatus {
398    pub program_state: Option<ProgramState>,
399    pub receipts: Vec<Receipt>,
400    pub total_gas: U64,
401    pub total_fee: U64,
402}
403
404#[derive(cynic::QueryFragment, Clone, Debug)]
405#[cynic(schema_path = "./assets/schema.sdl")]
406pub struct DryRunFailureStatus {
407    pub program_state: Option<ProgramState>,
408    pub receipts: Vec<Receipt>,
409    pub total_gas: U64,
410    pub total_fee: U64,
411}
412
413#[derive(cynic::QueryFragment, Clone, Debug)]
414#[cynic(schema_path = "./assets/schema.sdl")]
415pub struct DryRunTransactionExecutionStatus {
416    pub id: TransactionId,
417    pub status: DryRunTransactionStatus,
418}
419
420impl TryFrom<DryRunTransactionExecutionStatus> for TransactionExecutionStatus {
421    type Error = ConversionError;
422
423    fn try_from(schema: DryRunTransactionExecutionStatus) -> Result<Self, Self::Error> {
424        let id = schema.id.into();
425        let status = schema.status.try_into()?;
426
427        Ok(TransactionExecutionStatus { id, result: status })
428    }
429}
430
431#[derive(cynic::QueryVariables, Debug, Clone)]
432pub struct TransactionsByOwnerConnectionArgs {
433    /// Select transactions based on related `owner`s
434    pub owner: Address,
435    /// Skip until cursor (forward pagination)
436    pub after: Option<String>,
437    /// Skip until cursor (backward pagination)
438    pub before: Option<String>,
439    /// Retrieve the first n transactions in order (forward pagination)
440    pub first: Option<i32>,
441    /// Retrieve the last n transactions in order (backward pagination).
442    /// Can't be used at the same time as `first`.
443    pub last: Option<i32>,
444}
445
446impl From<(Address, PaginationRequest<String>)> for TransactionsByOwnerConnectionArgs {
447    fn from(r: (Address, PaginationRequest<String>)) -> Self {
448        match r.1.direction {
449            PageDirection::Forward => TransactionsByOwnerConnectionArgs {
450                owner: r.0,
451                after: r.1.cursor,
452                before: None,
453                first: Some(r.1.results),
454                last: None,
455            },
456            PageDirection::Backward => TransactionsByOwnerConnectionArgs {
457                owner: r.0,
458                after: None,
459                before: r.1.cursor,
460                first: None,
461                last: Some(r.1.results),
462            },
463        }
464    }
465}
466
467#[derive(cynic::QueryFragment, Clone, Debug)]
468#[cynic(
469    schema_path = "./assets/schema.sdl",
470    graphql_type = "Query",
471    variables = "TransactionsByOwnerConnectionArgs"
472)]
473pub struct TransactionsByOwnerQuery {
474    #[arguments(owner: $owner, after: $after, before: $before, first: $first, last: $last)]
475    pub transactions_by_owner: TransactionConnection,
476}
477
478#[derive(cynic::QueryVariables, Debug, Clone)]
479pub struct StatusChangeSubscriptionArgs {
480    pub id: TransactionId,
481    #[cynic(skip_serializing_if = "Option::is_none")]
482    pub include_preconfirmation: Option<bool>,
483}
484
485#[derive(cynic::QueryFragment, Clone, Debug)]
486#[cynic(
487    schema_path = "./assets/schema.sdl",
488    graphql_type = "Subscription",
489    variables = "StatusChangeSubscriptionArgs"
490)]
491pub struct StatusChangeSubscription {
492    #[arguments(id: $id, includePreconfirmation: $include_preconfirmation)]
493    pub status_change: TransactionStatus,
494}
495
496// mutations
497
498#[derive(cynic::QueryVariables, Clone)]
499pub struct TxArg {
500    pub tx: HexString,
501}
502
503#[derive(cynic::QueryVariables, Clone)]
504pub struct TxWithEstimatedPredicatesArg {
505    pub tx: HexString,
506    #[cynic(skip_serializing_if = "Option::is_none")]
507    pub estimate_predicates: Option<bool>,
508}
509
510#[derive(cynic::QueryVariables, Clone)]
511pub struct SubmitAndAwaitStatusArg {
512    pub tx: HexString,
513    #[cynic(skip_serializing_if = "Option::is_none")]
514    pub estimate_predicates: Option<bool>,
515    #[cynic(skip_serializing_if = "Option::is_none")]
516    pub include_preconfirmation: Option<bool>,
517}
518
519#[derive(cynic::QueryFragment, Clone, Debug)]
520#[cynic(
521    schema_path = "./assets/schema.sdl",
522    graphql_type = "Query",
523    variables = "TxArg"
524)]
525pub struct EstimatePredicates {
526    #[arguments(tx: $tx)]
527    pub estimate_predicates: OpaqueTransaction,
528}
529
530#[derive(cynic::InputObject, Clone, Debug)]
531#[cynic(schema_path = "./assets/schema.sdl")]
532pub struct Predicate {
533    pub predicate_address: Address,
534    pub predicate: HexString,
535    pub predicate_data: HexString,
536}
537
538#[derive(cynic::InputObject, Clone, Debug)]
539#[cynic(schema_path = "./assets/schema.sdl")]
540pub struct Account {
541    #[cynic(skip_serializing_if = "Option::is_none")]
542    pub address: Option<Address>,
543    #[cynic(skip_serializing_if = "Option::is_none")]
544    pub predicate: Option<Predicate>,
545}
546
547#[derive(cynic::InputObject, Clone, Debug)]
548#[cynic(schema_path = "./assets/schema.sdl")]
549pub struct ChangePolicy {
550    #[cynic(skip_serializing_if = "Option::is_none")]
551    pub change: Option<Address>,
552    #[cynic(skip_serializing_if = "Option::is_none")]
553    pub destroy: Option<Destroy>,
554}
555
556#[derive(cynic::Enum, Clone, Debug)]
557#[cynic(schema_path = "./assets/schema.sdl")]
558pub enum Destroy {
559    Destroy,
560}
561
562#[derive(cynic::InputObject, Clone, Debug)]
563#[cynic(schema_path = "./assets/schema.sdl")]
564pub struct RequiredBalance {
565    pub asset_id: AssetId,
566    pub amount: U64,
567    pub account: Account,
568    pub change_policy: ChangePolicy,
569}
570
571#[derive(cynic::QueryVariables, Clone)]
572pub struct AssembleTxArg {
573    pub tx: HexString,
574    pub block_horizon: U32,
575    pub required_balances: Vec<RequiredBalance>,
576    pub fee_address_index: U16,
577    pub exclude_input: Option<ExcludeInput>,
578    pub estimate_predicates: bool,
579    pub reserve_gas: Option<U64>,
580}
581
582#[derive(cynic::QueryFragment, Clone, Debug)]
583#[cynic(
584    schema_path = "./assets/schema.sdl",
585    graphql_type = "Query",
586    variables = "AssembleTxArg"
587)]
588pub struct AssembleTx {
589    #[arguments(
590        tx: $tx,
591        blockHorizon: $block_horizon,
592        requiredBalances: $required_balances,
593        feeAddressIndex: $fee_address_index,
594        excludeInput: $exclude_input,
595        estimatePredicates: $estimate_predicates,
596        reserveGas: $reserve_gas,
597    )]
598    pub assemble_tx: AssembleTransactionResult,
599}
600
601#[derive(cynic::QueryFragment, Clone, Debug)]
602#[cynic(schema_path = "./assets/schema.sdl")]
603pub struct AssembleTransactionResult {
604    pub transaction: OpaqueTransaction,
605    pub status: DryRunTransactionStatus,
606    pub gas_price: U64,
607}
608
609#[derive(cynic::QueryVariables, Clone)]
610pub struct DryRunArg {
611    pub txs: Vec<HexString>,
612    pub utxo_validation: Option<bool>,
613    pub gas_price: Option<U64>,
614    pub block_height: Option<U32>,
615}
616
617#[derive(cynic::QueryFragment, Clone, Debug)]
618#[cynic(
619    schema_path = "./assets/schema.sdl",
620    graphql_type = "Mutation",
621    variables = "DryRunArg"
622)]
623pub struct DryRun {
624    #[arguments(txs: $txs, utxoValidation: $utxo_validation, gasPrice: $gas_price, blockHeight: $block_height
625    )]
626    pub dry_run: Vec<DryRunTransactionExecutionStatus>,
627}
628
629#[derive(cynic::QueryFragment, Clone, Debug)]
630#[cynic(schema_path = "./assets/schema.sdl")]
631pub struct DryRunStorageReads {
632    pub tx_statuses: Vec<DryRunTransactionExecutionStatus>,
633    pub storage_reads: Vec<super::storage_read_replay::StorageReadReplayEvent>,
634}
635
636#[derive(cynic::QueryFragment, Clone, Debug)]
637#[cynic(
638    schema_path = "./assets/schema.sdl",
639    graphql_type = "Query",
640    variables = "DryRunArg"
641)]
642pub struct DryRunRecordStorageReads {
643    #[arguments(txs: $txs, utxoValidation: $utxo_validation, gasPrice: $gas_price, blockHeight: $block_height
644    )]
645    pub dry_run_record_storage_reads: DryRunStorageReads,
646}
647
648#[derive(cynic::QueryFragment, Clone, Debug)]
649#[cynic(
650    schema_path = "./assets/schema.sdl",
651    graphql_type = "Mutation",
652    variables = "TxWithEstimatedPredicatesArg"
653)]
654pub struct Submit {
655    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates)]
656    pub submit: TransactionIdFragment,
657}
658
659#[derive(cynic::QueryFragment, Clone, Debug)]
660#[cynic(
661    schema_path = "./assets/schema.sdl",
662    graphql_type = "Subscription",
663    variables = "TxWithEstimatedPredicatesArg"
664)]
665pub struct SubmitAndAwaitSubscription {
666    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates)]
667    pub submit_and_await: TransactionStatus,
668}
669
670#[derive(cynic::QueryFragment, Clone, Debug)]
671#[cynic(
672    schema_path = "./assets/schema.sdl",
673    graphql_type = "Subscription",
674    variables = "TxWithEstimatedPredicatesArg"
675)]
676pub struct SubmitAndAwaitSubscriptionWithTransaction {
677    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates)]
678    pub submit_and_await: StatusWithTransaction,
679}
680
681#[derive(cynic::QueryFragment, Clone, Debug)]
682#[cynic(
683    schema_path = "./assets/schema.sdl",
684    graphql_type = "Subscription",
685    variables = "SubmitAndAwaitStatusArg"
686)]
687pub struct SubmitAndAwaitStatusSubscription {
688    #[arguments(tx: $tx, estimatePredicates: $estimate_predicates, includePreconfirmation: $include_preconfirmation
689    )]
690    pub submit_and_await_status: TransactionStatus,
691}
692
693#[derive(cynic::QueryFragment, Clone, Debug)]
694#[cynic(schema_path = "./assets/schema.sdl", graphql_type = "Query")]
695pub struct AllReceipts {
696    pub all_receipts: Vec<Receipt>,
697}
698
699#[derive(cynic::QueryFragment, Clone, Debug)]
700#[cynic(schema_path = "./assets/schema.sdl", graphql_type = "Subscription")]
701pub struct PreconfirmationsSubscription {
702    #[cynic(rename = "alpha__preconfirmations")]
703    pub preconfirmations: TransactionStatus,
704}
705
706#[cfg(test)]
707pub mod tests {
708    use super::*;
709    use crate::client::schema::Bytes;
710    use fuel_core_types::fuel_types::canonical::Serialize;
711
712    #[cfg(not(feature = "test-helpers"))]
713    #[test]
714    fn transparent_transaction_by_id_query_gql_output() {
715        use cynic::QueryBuilder;
716        let operation = transparent_tx::TransactionQuery::build(TxIdArgs {
717            id: TransactionId::default(),
718        });
719        insta::assert_snapshot!(operation.query)
720    }
721
722    #[cfg(not(feature = "test-helpers"))]
723    #[test]
724    fn opaque_transaction_by_id_query_gql_output() {
725        use cynic::QueryBuilder;
726        let operation = TransactionQuery::build(TxIdArgs {
727            id: TransactionId::default(),
728        });
729        insta::assert_snapshot!(operation.query)
730    }
731
732    #[cfg(not(feature = "test-helpers"))]
733    #[test]
734    fn transactions_connection_query_gql_output() {
735        use cynic::QueryBuilder;
736
737        let args = crate::client::schema::ConnectionArgs {
738            after: None,
739            before: None,
740            first: None,
741            last: None,
742        };
743        let operation = TransactionsQuery::build(args);
744        insta::assert_snapshot!(operation.query)
745    }
746
747    #[cfg(not(feature = "test-helpers"))]
748    #[test]
749    fn transactions_by_owner_gql_output() {
750        use cynic::QueryBuilder;
751        let operation =
752            TransactionsByOwnerQuery::build(TransactionsByOwnerConnectionArgs {
753                owner: Default::default(),
754                after: None,
755                before: None,
756                first: None,
757                last: None,
758            });
759        insta::assert_snapshot!(operation.query)
760    }
761
762    #[test]
763    fn dry_run_tx_gql_output() {
764        use cynic::MutationBuilder;
765        let tx = fuel_tx::Transaction::default_test_tx();
766        let query = DryRun::build(DryRunArg {
767            txs: vec![HexString(Bytes(tx.to_bytes()))],
768            utxo_validation: Some(true),
769            gas_price: Some(123u64.into()),
770            block_height: Some(456u32.into()),
771        });
772        insta::assert_snapshot!(query.query)
773    }
774
775    #[test]
776    fn submit_tx_gql_output() {
777        use cynic::MutationBuilder;
778        let tx = fuel_tx::Transaction::default_test_tx();
779        let query = Submit::build(TxWithEstimatedPredicatesArg {
780            tx: HexString(Bytes(tx.to_bytes())),
781            estimate_predicates: Some(true),
782        });
783        insta::assert_snapshot!(query.query)
784    }
785}
fuel_core_client/client/schema/tx.rs

fuel_core_client/client/schema/
tx.rs
