@fuel-ts/account 0.90.0 → 0.91.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of @fuel-ts/account might be problematic. Click here for more details.
- package/dist/index.global.js +845 -432
- package/dist/index.global.js.map +1 -1
- package/dist/index.js +29 -9
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +29 -9
- package/dist/index.mjs.map +1 -1
- package/dist/providers/__generated__/operations.d.ts +655 -507
- package/dist/providers/__generated__/operations.d.ts.map +1 -1
- package/dist/providers/assets/utils/network.d.ts.map +1 -1
- package/dist/providers/utils/extract-tx-error.d.ts +2 -8
- package/dist/providers/utils/extract-tx-error.d.ts.map +1 -1
- package/dist/test-utils/launchNode.d.ts +3 -5
- package/dist/test-utils/launchNode.d.ts.map +1 -1
- package/dist/test-utils/setup-test-provider-and-wallets.d.ts +2 -1
- package/dist/test-utils/setup-test-provider-and-wallets.d.ts.map +1 -1
- package/dist/test-utils.global.js +894 -459
- package/dist/test-utils.global.js.map +1 -1
- package/dist/test-utils.js +67 -36
- package/dist/test-utils.js.map +1 -1
- package/dist/test-utils.mjs +66 -35
- package/dist/test-utils.mjs.map +1 -1
- package/package.json +23 -23
|
@@ -12,35 +12,109 @@ export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
|
|
|
12
12
|
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
|
|
13
13
|
[SubKey in K]: Maybe<T[SubKey]>;
|
|
14
14
|
};
|
|
15
|
+
export type MakeEmpty<T extends {
|
|
16
|
+
[key: string]: unknown;
|
|
17
|
+
}, K extends keyof T> = {
|
|
18
|
+
[_ in K]?: never;
|
|
19
|
+
};
|
|
20
|
+
export type Incremental<T> = T | {
|
|
21
|
+
[P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never;
|
|
22
|
+
};
|
|
15
23
|
/** All built-in and custom scalars, mapped to their actual values */
|
|
16
24
|
export type Scalars = {
|
|
17
|
-
ID:
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
25
|
+
ID: {
|
|
26
|
+
input: string;
|
|
27
|
+
output: string;
|
|
28
|
+
};
|
|
29
|
+
String: {
|
|
30
|
+
input: string;
|
|
31
|
+
output: string;
|
|
32
|
+
};
|
|
33
|
+
Boolean: {
|
|
34
|
+
input: boolean;
|
|
35
|
+
output: boolean;
|
|
36
|
+
};
|
|
37
|
+
Int: {
|
|
38
|
+
input: number;
|
|
39
|
+
output: number;
|
|
40
|
+
};
|
|
41
|
+
Float: {
|
|
42
|
+
input: number;
|
|
43
|
+
output: number;
|
|
44
|
+
};
|
|
45
|
+
Address: {
|
|
46
|
+
input: string;
|
|
47
|
+
output: string;
|
|
48
|
+
};
|
|
49
|
+
AssetId: {
|
|
50
|
+
input: string;
|
|
51
|
+
output: string;
|
|
52
|
+
};
|
|
53
|
+
BlockId: {
|
|
54
|
+
input: string;
|
|
55
|
+
output: string;
|
|
56
|
+
};
|
|
57
|
+
Bytes32: {
|
|
58
|
+
input: string;
|
|
59
|
+
output: string;
|
|
60
|
+
};
|
|
61
|
+
ContractId: {
|
|
62
|
+
input: string;
|
|
63
|
+
output: string;
|
|
64
|
+
};
|
|
65
|
+
HexString: {
|
|
66
|
+
input: string;
|
|
67
|
+
output: string;
|
|
68
|
+
};
|
|
69
|
+
Nonce: {
|
|
70
|
+
input: string;
|
|
71
|
+
output: string;
|
|
72
|
+
};
|
|
73
|
+
RelayedTransactionId: {
|
|
74
|
+
input: string;
|
|
75
|
+
output: string;
|
|
76
|
+
};
|
|
77
|
+
Salt: {
|
|
78
|
+
input: string;
|
|
79
|
+
output: string;
|
|
80
|
+
};
|
|
81
|
+
Signature: {
|
|
82
|
+
input: string;
|
|
83
|
+
output: string;
|
|
84
|
+
};
|
|
85
|
+
Tai64Timestamp: {
|
|
86
|
+
input: string;
|
|
87
|
+
output: string;
|
|
88
|
+
};
|
|
89
|
+
TransactionId: {
|
|
90
|
+
input: string;
|
|
91
|
+
output: string;
|
|
92
|
+
};
|
|
93
|
+
TxPointer: {
|
|
94
|
+
input: string;
|
|
95
|
+
output: string;
|
|
96
|
+
};
|
|
97
|
+
U16: {
|
|
98
|
+
input: string;
|
|
99
|
+
output: string;
|
|
100
|
+
};
|
|
101
|
+
U32: {
|
|
102
|
+
input: string;
|
|
103
|
+
output: string;
|
|
104
|
+
};
|
|
105
|
+
U64: {
|
|
106
|
+
input: string;
|
|
107
|
+
output: string;
|
|
108
|
+
};
|
|
109
|
+
UtxoId: {
|
|
110
|
+
input: string;
|
|
111
|
+
output: string;
|
|
112
|
+
};
|
|
39
113
|
};
|
|
40
114
|
export type GqlBalance = {
|
|
41
|
-
amount: Scalars['U64'];
|
|
42
|
-
assetId: Scalars['AssetId'];
|
|
43
|
-
owner: Scalars['Address'];
|
|
115
|
+
amount: Scalars['U64']['output'];
|
|
116
|
+
assetId: Scalars['AssetId']['output'];
|
|
117
|
+
owner: Scalars['Address']['output'];
|
|
44
118
|
};
|
|
45
119
|
export type GqlBalanceConnection = {
|
|
46
120
|
/** A list of edges. */
|
|
@@ -53,19 +127,19 @@ export type GqlBalanceConnection = {
|
|
|
53
127
|
/** An edge in a connection. */
|
|
54
128
|
export type GqlBalanceEdge = {
|
|
55
129
|
/** A cursor for use in pagination */
|
|
56
|
-
cursor: Scalars['String'];
|
|
130
|
+
cursor: Scalars['String']['output'];
|
|
57
131
|
/** The item at the end of the edge */
|
|
58
132
|
node: GqlBalance;
|
|
59
133
|
};
|
|
60
134
|
export type GqlBalanceFilterInput = {
|
|
61
135
|
/** Filter coins based on the `owner` field */
|
|
62
|
-
owner: Scalars['Address'];
|
|
136
|
+
owner: Scalars['Address']['input'];
|
|
63
137
|
};
|
|
64
138
|
export type GqlBlock = {
|
|
65
139
|
consensus: GqlConsensus;
|
|
66
140
|
header: GqlHeader;
|
|
67
|
-
height: Scalars['U32'];
|
|
68
|
-
id: Scalars['BlockId'];
|
|
141
|
+
height: Scalars['U32']['output'];
|
|
142
|
+
id: Scalars['BlockId']['output'];
|
|
69
143
|
transactions: Array<GqlTransaction>;
|
|
70
144
|
version: GqlBlockVersion;
|
|
71
145
|
};
|
|
@@ -80,7 +154,7 @@ export type GqlBlockConnection = {
|
|
|
80
154
|
/** An edge in a connection. */
|
|
81
155
|
export type GqlBlockEdge = {
|
|
82
156
|
/** A cursor for use in pagination */
|
|
83
|
-
cursor: Scalars['String'];
|
|
157
|
+
cursor: Scalars['String']['output'];
|
|
84
158
|
/** The item at the end of the edge */
|
|
85
159
|
node: GqlBlock;
|
|
86
160
|
};
|
|
@@ -89,30 +163,30 @@ export declare enum GqlBlockVersion {
|
|
|
89
163
|
}
|
|
90
164
|
/** Breakpoint, defined as a tuple of contract ID and relative PC offset inside it */
|
|
91
165
|
export type GqlBreakpoint = {
|
|
92
|
-
contract: Scalars['ContractId'];
|
|
93
|
-
pc: Scalars['U64'];
|
|
166
|
+
contract: Scalars['ContractId']['input'];
|
|
167
|
+
pc: Scalars['U64']['input'];
|
|
94
168
|
};
|
|
95
169
|
export type GqlChainInfo = {
|
|
96
170
|
consensusParameters: GqlConsensusParameters;
|
|
97
|
-
daHeight: Scalars['U64'];
|
|
171
|
+
daHeight: Scalars['U64']['output'];
|
|
98
172
|
gasCosts: GqlGasCosts;
|
|
99
173
|
latestBlock: GqlBlock;
|
|
100
|
-
name: Scalars['String'];
|
|
174
|
+
name: Scalars['String']['output'];
|
|
101
175
|
};
|
|
102
176
|
export type GqlChangeOutput = {
|
|
103
|
-
amount: Scalars['U64'];
|
|
104
|
-
assetId: Scalars['AssetId'];
|
|
105
|
-
to: Scalars['Address'];
|
|
177
|
+
amount: Scalars['U64']['output'];
|
|
178
|
+
assetId: Scalars['AssetId']['output'];
|
|
179
|
+
to: Scalars['Address']['output'];
|
|
106
180
|
};
|
|
107
181
|
export type GqlCoin = {
|
|
108
|
-
amount: Scalars['U64'];
|
|
109
|
-
assetId: Scalars['AssetId'];
|
|
182
|
+
amount: Scalars['U64']['output'];
|
|
183
|
+
assetId: Scalars['AssetId']['output'];
|
|
110
184
|
/** TxPointer - the height of the block this coin was created in */
|
|
111
|
-
blockCreated: Scalars['U32'];
|
|
112
|
-
owner: Scalars['Address'];
|
|
185
|
+
blockCreated: Scalars['U32']['output'];
|
|
186
|
+
owner: Scalars['Address']['output'];
|
|
113
187
|
/** TxPointer - the index of the transaction that created this coin */
|
|
114
|
-
txCreatedIdx: Scalars['U16'];
|
|
115
|
-
utxoId: Scalars['UtxoId'];
|
|
188
|
+
txCreatedIdx: Scalars['U16']['output'];
|
|
189
|
+
utxoId: Scalars['UtxoId']['output'];
|
|
116
190
|
};
|
|
117
191
|
export type GqlCoinConnection = {
|
|
118
192
|
/** A list of edges. */
|
|
@@ -125,53 +199,53 @@ export type GqlCoinConnection = {
|
|
|
125
199
|
/** An edge in a connection. */
|
|
126
200
|
export type GqlCoinEdge = {
|
|
127
201
|
/** A cursor for use in pagination */
|
|
128
|
-
cursor: Scalars['String'];
|
|
202
|
+
cursor: Scalars['String']['output'];
|
|
129
203
|
/** The item at the end of the edge */
|
|
130
204
|
node: GqlCoin;
|
|
131
205
|
};
|
|
132
206
|
export type GqlCoinFilterInput = {
|
|
133
207
|
/** Returns coins only with `asset_id`. */
|
|
134
|
-
assetId?: InputMaybe<Scalars['AssetId']>;
|
|
208
|
+
assetId?: InputMaybe<Scalars['AssetId']['input']>;
|
|
135
209
|
/** Returns coins owned by the `owner`. */
|
|
136
|
-
owner: Scalars['Address'];
|
|
210
|
+
owner: Scalars['Address']['input'];
|
|
137
211
|
};
|
|
138
212
|
export type GqlCoinOutput = {
|
|
139
|
-
amount: Scalars['U64'];
|
|
140
|
-
assetId: Scalars['AssetId'];
|
|
141
|
-
to: Scalars['Address'];
|
|
213
|
+
amount: Scalars['U64']['output'];
|
|
214
|
+
assetId: Scalars['AssetId']['output'];
|
|
215
|
+
to: Scalars['Address']['output'];
|
|
142
216
|
};
|
|
143
217
|
/** The schema analog of the [`coins::CoinType`]. */
|
|
144
218
|
export type GqlCoinType = GqlCoin | GqlMessageCoin;
|
|
145
219
|
export type GqlConsensus = GqlGenesis | GqlPoAConsensus;
|
|
146
220
|
export type GqlConsensusParameters = {
|
|
147
|
-
baseAssetId: Scalars['AssetId'];
|
|
148
|
-
blockGasLimit: Scalars['U64'];
|
|
149
|
-
chainId: Scalars['U64'];
|
|
221
|
+
baseAssetId: Scalars['AssetId']['output'];
|
|
222
|
+
blockGasLimit: Scalars['U64']['output'];
|
|
223
|
+
chainId: Scalars['U64']['output'];
|
|
150
224
|
contractParams: GqlContractParameters;
|
|
151
225
|
feeParams: GqlFeeParameters;
|
|
152
226
|
gasCosts: GqlGasCosts;
|
|
153
227
|
predicateParams: GqlPredicateParameters;
|
|
154
|
-
privilegedAddress: Scalars['Address'];
|
|
228
|
+
privilegedAddress: Scalars['Address']['output'];
|
|
155
229
|
scriptParams: GqlScriptParameters;
|
|
156
230
|
txParams: GqlTxParameters;
|
|
157
231
|
version: GqlConsensusParametersVersion;
|
|
158
232
|
};
|
|
159
233
|
export type GqlConsensusParametersPurpose = {
|
|
160
|
-
checksum: Scalars['Bytes32'];
|
|
161
|
-
witnessIndex: Scalars['U16'];
|
|
234
|
+
checksum: Scalars['Bytes32']['output'];
|
|
235
|
+
witnessIndex: Scalars['U16']['output'];
|
|
162
236
|
};
|
|
163
237
|
export declare enum GqlConsensusParametersVersion {
|
|
164
238
|
V1 = "V1"
|
|
165
239
|
}
|
|
166
240
|
export type GqlContract = {
|
|
167
|
-
bytecode: Scalars['HexString'];
|
|
168
|
-
id: Scalars['ContractId'];
|
|
169
|
-
salt: Scalars['Salt'];
|
|
241
|
+
bytecode: Scalars['HexString']['output'];
|
|
242
|
+
id: Scalars['ContractId']['output'];
|
|
243
|
+
salt: Scalars['Salt']['output'];
|
|
170
244
|
};
|
|
171
245
|
export type GqlContractBalance = {
|
|
172
|
-
amount: Scalars['U64'];
|
|
173
|
-
assetId: Scalars['AssetId'];
|
|
174
|
-
contract: Scalars['ContractId'];
|
|
246
|
+
amount: Scalars['U64']['output'];
|
|
247
|
+
assetId: Scalars['AssetId']['output'];
|
|
248
|
+
contract: Scalars['ContractId']['output'];
|
|
175
249
|
};
|
|
176
250
|
export type GqlContractBalanceConnection = {
|
|
177
251
|
/** A list of edges. */
|
|
@@ -184,26 +258,26 @@ export type GqlContractBalanceConnection = {
|
|
|
184
258
|
/** An edge in a connection. */
|
|
185
259
|
export type GqlContractBalanceEdge = {
|
|
186
260
|
/** A cursor for use in pagination */
|
|
187
|
-
cursor: Scalars['String'];
|
|
261
|
+
cursor: Scalars['String']['output'];
|
|
188
262
|
/** The item at the end of the edge */
|
|
189
263
|
node: GqlContractBalance;
|
|
190
264
|
};
|
|
191
265
|
export type GqlContractBalanceFilterInput = {
|
|
192
266
|
/** Filter assets based on the `contractId` field */
|
|
193
|
-
contract: Scalars['ContractId'];
|
|
267
|
+
contract: Scalars['ContractId']['input'];
|
|
194
268
|
};
|
|
195
269
|
export type GqlContractCreated = {
|
|
196
|
-
contract: Scalars['ContractId'];
|
|
197
|
-
stateRoot: Scalars['Bytes32'];
|
|
270
|
+
contract: Scalars['ContractId']['output'];
|
|
271
|
+
stateRoot: Scalars['Bytes32']['output'];
|
|
198
272
|
};
|
|
199
273
|
export type GqlContractOutput = {
|
|
200
|
-
balanceRoot: Scalars['Bytes32'];
|
|
201
|
-
inputIndex: Scalars['U16'];
|
|
202
|
-
stateRoot: Scalars['Bytes32'];
|
|
274
|
+
balanceRoot: Scalars['Bytes32']['output'];
|
|
275
|
+
inputIndex: Scalars['U16']['output'];
|
|
276
|
+
stateRoot: Scalars['Bytes32']['output'];
|
|
203
277
|
};
|
|
204
278
|
export type GqlContractParameters = {
|
|
205
|
-
contractMaxSize: Scalars['U64'];
|
|
206
|
-
maxStorageSlots: Scalars['U64'];
|
|
279
|
+
contractMaxSize: Scalars['U64']['output'];
|
|
280
|
+
maxStorageSlots: Scalars['U64']['output'];
|
|
207
281
|
version: GqlContractParametersVersion;
|
|
208
282
|
};
|
|
209
283
|
export declare enum GqlContractParametersVersion {
|
|
@@ -212,163 +286,165 @@ export declare enum GqlContractParametersVersion {
|
|
|
212
286
|
export type GqlDependentCost = GqlHeavyOperation | GqlLightOperation;
|
|
213
287
|
export type GqlDryRunFailureStatus = {
|
|
214
288
|
programState?: Maybe<GqlProgramState>;
|
|
215
|
-
reason: Scalars['String'];
|
|
289
|
+
reason: Scalars['String']['output'];
|
|
216
290
|
receipts: Array<GqlReceipt>;
|
|
217
|
-
totalFee: Scalars['U64'];
|
|
218
|
-
totalGas: Scalars['U64'];
|
|
291
|
+
totalFee: Scalars['U64']['output'];
|
|
292
|
+
totalGas: Scalars['U64']['output'];
|
|
219
293
|
};
|
|
220
294
|
export type GqlDryRunSuccessStatus = {
|
|
221
295
|
programState?: Maybe<GqlProgramState>;
|
|
222
296
|
receipts: Array<GqlReceipt>;
|
|
223
|
-
totalFee: Scalars['U64'];
|
|
224
|
-
totalGas: Scalars['U64'];
|
|
297
|
+
totalFee: Scalars['U64']['output'];
|
|
298
|
+
totalGas: Scalars['U64']['output'];
|
|
225
299
|
};
|
|
226
300
|
export type GqlDryRunTransactionExecutionStatus = {
|
|
227
|
-
id: Scalars['TransactionId'];
|
|
301
|
+
id: Scalars['TransactionId']['output'];
|
|
228
302
|
receipts: Array<GqlReceipt>;
|
|
229
303
|
status: GqlDryRunTransactionStatus;
|
|
230
304
|
};
|
|
231
305
|
export type GqlDryRunTransactionStatus = GqlDryRunFailureStatus | GqlDryRunSuccessStatus;
|
|
232
306
|
export type GqlEstimateGasPrice = {
|
|
233
|
-
gasPrice: Scalars['U64'];
|
|
307
|
+
gasPrice: Scalars['U64']['output'];
|
|
234
308
|
};
|
|
235
309
|
export type GqlExcludeInput = {
|
|
236
310
|
/** Messages to exclude from the selection. */
|
|
237
|
-
messages: Array<Scalars['Nonce']>;
|
|
311
|
+
messages: Array<Scalars['Nonce']['input']>;
|
|
238
312
|
/** Utxos to exclude from the selection. */
|
|
239
|
-
utxos: Array<Scalars['UtxoId']>;
|
|
313
|
+
utxos: Array<Scalars['UtxoId']['input']>;
|
|
240
314
|
};
|
|
241
315
|
export type GqlFailureStatus = {
|
|
242
316
|
block: GqlBlock;
|
|
243
317
|
programState?: Maybe<GqlProgramState>;
|
|
244
|
-
reason: Scalars['String'];
|
|
318
|
+
reason: Scalars['String']['output'];
|
|
245
319
|
receipts: Array<GqlReceipt>;
|
|
246
|
-
time: Scalars['Tai64Timestamp'];
|
|
247
|
-
totalFee: Scalars['U64'];
|
|
248
|
-
totalGas: Scalars['U64'];
|
|
249
|
-
transactionId: Scalars['TransactionId'];
|
|
320
|
+
time: Scalars['Tai64Timestamp']['output'];
|
|
321
|
+
totalFee: Scalars['U64']['output'];
|
|
322
|
+
totalGas: Scalars['U64']['output'];
|
|
323
|
+
transactionId: Scalars['TransactionId']['output'];
|
|
250
324
|
};
|
|
251
325
|
export type GqlFeeParameters = {
|
|
252
|
-
gasPerByte: Scalars['U64'];
|
|
253
|
-
gasPriceFactor: Scalars['U64'];
|
|
326
|
+
gasPerByte: Scalars['U64']['output'];
|
|
327
|
+
gasPriceFactor: Scalars['U64']['output'];
|
|
254
328
|
version: GqlFeeParametersVersion;
|
|
255
329
|
};
|
|
256
330
|
export declare enum GqlFeeParametersVersion {
|
|
257
331
|
V1 = "V1"
|
|
258
332
|
}
|
|
259
333
|
export type GqlGasCosts = {
|
|
260
|
-
add: Scalars['U64'];
|
|
261
|
-
addi: Scalars['U64'];
|
|
262
|
-
aloc: Scalars['U64'];
|
|
334
|
+
add: Scalars['U64']['output'];
|
|
335
|
+
addi: Scalars['U64']['output'];
|
|
336
|
+
aloc: Scalars['U64']['output'];
|
|
263
337
|
alocDependentCost: GqlDependentCost;
|
|
264
|
-
and: Scalars['U64'];
|
|
265
|
-
andi: Scalars['U64'];
|
|
266
|
-
bal: Scalars['U64'];
|
|
267
|
-
bhei: Scalars['U64'];
|
|
268
|
-
bhsh: Scalars['U64'];
|
|
269
|
-
burn: Scalars['U64'];
|
|
338
|
+
and: Scalars['U64']['output'];
|
|
339
|
+
andi: Scalars['U64']['output'];
|
|
340
|
+
bal: Scalars['U64']['output'];
|
|
341
|
+
bhei: Scalars['U64']['output'];
|
|
342
|
+
bhsh: Scalars['U64']['output'];
|
|
343
|
+
burn: Scalars['U64']['output'];
|
|
270
344
|
call: GqlDependentCost;
|
|
271
|
-
cb: Scalars['U64'];
|
|
345
|
+
cb: Scalars['U64']['output'];
|
|
272
346
|
ccp: GqlDependentCost;
|
|
273
|
-
|
|
274
|
-
|
|
347
|
+
cfe: GqlDependentCost;
|
|
348
|
+
cfei: Scalars['U64']['output'];
|
|
349
|
+
cfeiDependentCost: GqlDependentCost;
|
|
350
|
+
cfsi: Scalars['U64']['output'];
|
|
275
351
|
contractRoot: GqlDependentCost;
|
|
276
352
|
croo: GqlDependentCost;
|
|
277
353
|
csiz: GqlDependentCost;
|
|
278
|
-
div: Scalars['U64'];
|
|
279
|
-
divi: Scalars['U64'];
|
|
280
|
-
eck1: Scalars['U64'];
|
|
281
|
-
ecr1: Scalars['U64'];
|
|
282
|
-
ed19: Scalars['U64'];
|
|
283
|
-
eq: Scalars['U64'];
|
|
284
|
-
exp: Scalars['U64'];
|
|
285
|
-
expi: Scalars['U64'];
|
|
286
|
-
flag: Scalars['U64'];
|
|
287
|
-
gm: Scalars['U64'];
|
|
288
|
-
gt: Scalars['U64'];
|
|
289
|
-
gtf: Scalars['U64'];
|
|
290
|
-
ji: Scalars['U64'];
|
|
291
|
-
jmp: Scalars['U64'];
|
|
292
|
-
jmpb: Scalars['U64'];
|
|
293
|
-
jmpf: Scalars['U64'];
|
|
294
|
-
jne: Scalars['U64'];
|
|
295
|
-
jneb: Scalars['U64'];
|
|
296
|
-
jnef: Scalars['U64'];
|
|
297
|
-
jnei: Scalars['U64'];
|
|
298
|
-
jnzb: Scalars['U64'];
|
|
299
|
-
jnzf: Scalars['U64'];
|
|
300
|
-
jnzi: Scalars['U64'];
|
|
354
|
+
div: Scalars['U64']['output'];
|
|
355
|
+
divi: Scalars['U64']['output'];
|
|
356
|
+
eck1: Scalars['U64']['output'];
|
|
357
|
+
ecr1: Scalars['U64']['output'];
|
|
358
|
+
ed19: Scalars['U64']['output'];
|
|
359
|
+
eq: Scalars['U64']['output'];
|
|
360
|
+
exp: Scalars['U64']['output'];
|
|
361
|
+
expi: Scalars['U64']['output'];
|
|
362
|
+
flag: Scalars['U64']['output'];
|
|
363
|
+
gm: Scalars['U64']['output'];
|
|
364
|
+
gt: Scalars['U64']['output'];
|
|
365
|
+
gtf: Scalars['U64']['output'];
|
|
366
|
+
ji: Scalars['U64']['output'];
|
|
367
|
+
jmp: Scalars['U64']['output'];
|
|
368
|
+
jmpb: Scalars['U64']['output'];
|
|
369
|
+
jmpf: Scalars['U64']['output'];
|
|
370
|
+
jne: Scalars['U64']['output'];
|
|
371
|
+
jneb: Scalars['U64']['output'];
|
|
372
|
+
jnef: Scalars['U64']['output'];
|
|
373
|
+
jnei: Scalars['U64']['output'];
|
|
374
|
+
jnzb: Scalars['U64']['output'];
|
|
375
|
+
jnzf: Scalars['U64']['output'];
|
|
376
|
+
jnzi: Scalars['U64']['output'];
|
|
301
377
|
k256: GqlDependentCost;
|
|
302
|
-
lb: Scalars['U64'];
|
|
378
|
+
lb: Scalars['U64']['output'];
|
|
303
379
|
ldc: GqlDependentCost;
|
|
304
|
-
log: Scalars['U64'];
|
|
380
|
+
log: Scalars['U64']['output'];
|
|
305
381
|
logd: GqlDependentCost;
|
|
306
|
-
lt: Scalars['U64'];
|
|
307
|
-
lw: Scalars['U64'];
|
|
382
|
+
lt: Scalars['U64']['output'];
|
|
383
|
+
lw: Scalars['U64']['output'];
|
|
308
384
|
mcl: GqlDependentCost;
|
|
309
385
|
mcli: GqlDependentCost;
|
|
310
386
|
mcp: GqlDependentCost;
|
|
311
387
|
mcpi: GqlDependentCost;
|
|
312
388
|
meq: GqlDependentCost;
|
|
313
|
-
mint: Scalars['U64'];
|
|
314
|
-
mldv: Scalars['U64'];
|
|
315
|
-
mlog: Scalars['U64'];
|
|
316
|
-
modOp: Scalars['U64'];
|
|
317
|
-
modi: Scalars['U64'];
|
|
318
|
-
moveOp: Scalars['U64'];
|
|
319
|
-
movi: Scalars['U64'];
|
|
320
|
-
mroo: Scalars['U64'];
|
|
321
|
-
mul: Scalars['U64'];
|
|
322
|
-
muli: Scalars['U64'];
|
|
323
|
-
newStoragePerByte: Scalars['U64'];
|
|
324
|
-
noop: Scalars['U64'];
|
|
325
|
-
not: Scalars['U64'];
|
|
326
|
-
or: Scalars['U64'];
|
|
327
|
-
ori: Scalars['U64'];
|
|
328
|
-
poph: Scalars['U64'];
|
|
329
|
-
popl: Scalars['U64'];
|
|
330
|
-
pshh: Scalars['U64'];
|
|
331
|
-
pshl: Scalars['U64'];
|
|
332
|
-
ret: Scalars['U64'];
|
|
389
|
+
mint: Scalars['U64']['output'];
|
|
390
|
+
mldv: Scalars['U64']['output'];
|
|
391
|
+
mlog: Scalars['U64']['output'];
|
|
392
|
+
modOp: Scalars['U64']['output'];
|
|
393
|
+
modi: Scalars['U64']['output'];
|
|
394
|
+
moveOp: Scalars['U64']['output'];
|
|
395
|
+
movi: Scalars['U64']['output'];
|
|
396
|
+
mroo: Scalars['U64']['output'];
|
|
397
|
+
mul: Scalars['U64']['output'];
|
|
398
|
+
muli: Scalars['U64']['output'];
|
|
399
|
+
newStoragePerByte: Scalars['U64']['output'];
|
|
400
|
+
noop: Scalars['U64']['output'];
|
|
401
|
+
not: Scalars['U64']['output'];
|
|
402
|
+
or: Scalars['U64']['output'];
|
|
403
|
+
ori: Scalars['U64']['output'];
|
|
404
|
+
poph: Scalars['U64']['output'];
|
|
405
|
+
popl: Scalars['U64']['output'];
|
|
406
|
+
pshh: Scalars['U64']['output'];
|
|
407
|
+
pshl: Scalars['U64']['output'];
|
|
408
|
+
ret: Scalars['U64']['output'];
|
|
333
409
|
retd: GqlDependentCost;
|
|
334
|
-
rvrt: Scalars['U64'];
|
|
410
|
+
rvrt: Scalars['U64']['output'];
|
|
335
411
|
s256: GqlDependentCost;
|
|
336
|
-
sb: Scalars['U64'];
|
|
412
|
+
sb: Scalars['U64']['output'];
|
|
337
413
|
scwq: GqlDependentCost;
|
|
338
|
-
sll: Scalars['U64'];
|
|
339
|
-
slli: Scalars['U64'];
|
|
414
|
+
sll: Scalars['U64']['output'];
|
|
415
|
+
slli: Scalars['U64']['output'];
|
|
340
416
|
smo: GqlDependentCost;
|
|
341
|
-
srl: Scalars['U64'];
|
|
342
|
-
srli: Scalars['U64'];
|
|
343
|
-
srw: Scalars['U64'];
|
|
417
|
+
srl: Scalars['U64']['output'];
|
|
418
|
+
srli: Scalars['U64']['output'];
|
|
419
|
+
srw: Scalars['U64']['output'];
|
|
344
420
|
srwq: GqlDependentCost;
|
|
345
421
|
stateRoot: GqlDependentCost;
|
|
346
|
-
sub: Scalars['U64'];
|
|
347
|
-
subi: Scalars['U64'];
|
|
348
|
-
sw: Scalars['U64'];
|
|
349
|
-
sww: Scalars['U64'];
|
|
422
|
+
sub: Scalars['U64']['output'];
|
|
423
|
+
subi: Scalars['U64']['output'];
|
|
424
|
+
sw: Scalars['U64']['output'];
|
|
425
|
+
sww: Scalars['U64']['output'];
|
|
350
426
|
swwq: GqlDependentCost;
|
|
351
|
-
time: Scalars['U64'];
|
|
352
|
-
tr: Scalars['U64'];
|
|
353
|
-
tro: Scalars['U64'];
|
|
427
|
+
time: Scalars['U64']['output'];
|
|
428
|
+
tr: Scalars['U64']['output'];
|
|
429
|
+
tro: Scalars['U64']['output'];
|
|
354
430
|
version: GqlGasCostsVersion;
|
|
355
431
|
vmInitialization: GqlDependentCost;
|
|
356
|
-
wdam: Scalars['U64'];
|
|
357
|
-
wdcm: Scalars['U64'];
|
|
358
|
-
wddv: Scalars['U64'];
|
|
359
|
-
wdmd: Scalars['U64'];
|
|
360
|
-
wdml: Scalars['U64'];
|
|
361
|
-
wdmm: Scalars['U64'];
|
|
362
|
-
wdop: Scalars['U64'];
|
|
363
|
-
wqam: Scalars['U64'];
|
|
364
|
-
wqcm: Scalars['U64'];
|
|
365
|
-
wqdv: Scalars['U64'];
|
|
366
|
-
wqmd: Scalars['U64'];
|
|
367
|
-
wqml: Scalars['U64'];
|
|
368
|
-
wqmm: Scalars['U64'];
|
|
369
|
-
wqop: Scalars['U64'];
|
|
370
|
-
xor: Scalars['U64'];
|
|
371
|
-
xori: Scalars['U64'];
|
|
432
|
+
wdam: Scalars['U64']['output'];
|
|
433
|
+
wdcm: Scalars['U64']['output'];
|
|
434
|
+
wddv: Scalars['U64']['output'];
|
|
435
|
+
wdmd: Scalars['U64']['output'];
|
|
436
|
+
wdml: Scalars['U64']['output'];
|
|
437
|
+
wdmm: Scalars['U64']['output'];
|
|
438
|
+
wdop: Scalars['U64']['output'];
|
|
439
|
+
wqam: Scalars['U64']['output'];
|
|
440
|
+
wqcm: Scalars['U64']['output'];
|
|
441
|
+
wqdv: Scalars['U64']['output'];
|
|
442
|
+
wqmd: Scalars['U64']['output'];
|
|
443
|
+
wqml: Scalars['U64']['output'];
|
|
444
|
+
wqmm: Scalars['U64']['output'];
|
|
445
|
+
wqop: Scalars['U64']['output'];
|
|
446
|
+
xor: Scalars['U64']['output'];
|
|
447
|
+
xori: Scalars['U64']['output'];
|
|
372
448
|
};
|
|
373
449
|
export declare enum GqlGasCostsVersion {
|
|
374
450
|
V1 = "V1"
|
|
@@ -378,43 +454,43 @@ export type GqlGenesis = {
|
|
|
378
454
|
* The chain configs define what consensus type to use, what settlement layer to use,
|
|
379
455
|
* rules of block validity, etc.
|
|
380
456
|
*/
|
|
381
|
-
chainConfigHash: Scalars['Bytes32'];
|
|
457
|
+
chainConfigHash: Scalars['Bytes32']['output'];
|
|
382
458
|
/** The Binary Merkle Tree root of all genesis coins. */
|
|
383
|
-
coinsRoot: Scalars['Bytes32'];
|
|
459
|
+
coinsRoot: Scalars['Bytes32']['output'];
|
|
384
460
|
/** The Binary Merkle Tree root of state, balances, contracts code hash of each contract. */
|
|
385
|
-
contractsRoot: Scalars['Bytes32'];
|
|
461
|
+
contractsRoot: Scalars['Bytes32']['output'];
|
|
386
462
|
/** The Binary Merkle Tree root of all genesis messages. */
|
|
387
|
-
messagesRoot: Scalars['Bytes32'];
|
|
463
|
+
messagesRoot: Scalars['Bytes32']['output'];
|
|
388
464
|
/** The Binary Merkle Tree root of all processed transaction ids. */
|
|
389
|
-
transactionsRoot: Scalars['Bytes32'];
|
|
465
|
+
transactionsRoot: Scalars['Bytes32']['output'];
|
|
390
466
|
};
|
|
391
467
|
export type GqlHeader = {
|
|
392
468
|
/** Hash of the application header. */
|
|
393
|
-
applicationHash: Scalars['Bytes32'];
|
|
469
|
+
applicationHash: Scalars['Bytes32']['output'];
|
|
394
470
|
/** The version of the consensus parameters used to create this block. */
|
|
395
|
-
consensusParametersVersion: Scalars['U32'];
|
|
471
|
+
consensusParametersVersion: Scalars['U32']['output'];
|
|
396
472
|
/** The layer 1 height of messages and events to include since the last layer 1 block number. */
|
|
397
|
-
daHeight: Scalars['U64'];
|
|
473
|
+
daHeight: Scalars['U64']['output'];
|
|
398
474
|
/** Merkle root of inbox events in this block. */
|
|
399
|
-
eventInboxRoot: Scalars['Bytes32'];
|
|
475
|
+
eventInboxRoot: Scalars['Bytes32']['output'];
|
|
400
476
|
/** Fuel block height. */
|
|
401
|
-
height: Scalars['U32'];
|
|
477
|
+
height: Scalars['U32']['output'];
|
|
402
478
|
/** Hash of the header */
|
|
403
|
-
id: Scalars['BlockId'];
|
|
479
|
+
id: Scalars['BlockId']['output'];
|
|
404
480
|
/** Merkle root of message receipts in this block. */
|
|
405
|
-
messageOutboxRoot: Scalars['Bytes32'];
|
|
481
|
+
messageOutboxRoot: Scalars['Bytes32']['output'];
|
|
406
482
|
/** Number of message receipts in this block. */
|
|
407
|
-
messageReceiptCount: Scalars['U32'];
|
|
483
|
+
messageReceiptCount: Scalars['U32']['output'];
|
|
408
484
|
/** Merkle root of all previous block header hashes. */
|
|
409
|
-
prevRoot: Scalars['Bytes32'];
|
|
485
|
+
prevRoot: Scalars['Bytes32']['output'];
|
|
410
486
|
/** The version of the state transition bytecode used to create this block. */
|
|
411
|
-
stateTransitionBytecodeVersion: Scalars['U32'];
|
|
487
|
+
stateTransitionBytecodeVersion: Scalars['U32']['output'];
|
|
412
488
|
/** The block producer time. */
|
|
413
|
-
time: Scalars['Tai64Timestamp'];
|
|
489
|
+
time: Scalars['Tai64Timestamp']['output'];
|
|
414
490
|
/** Number of transactions in this block. */
|
|
415
|
-
transactionsCount: Scalars['U16'];
|
|
491
|
+
transactionsCount: Scalars['U16']['output'];
|
|
416
492
|
/** Merkle root of transactions. */
|
|
417
|
-
transactionsRoot: Scalars['Bytes32'];
|
|
493
|
+
transactionsRoot: Scalars['Bytes32']['output'];
|
|
418
494
|
/** Version of the header */
|
|
419
495
|
version: GqlHeaderVersion;
|
|
420
496
|
};
|
|
@@ -422,66 +498,66 @@ export declare enum GqlHeaderVersion {
|
|
|
422
498
|
V1 = "V1"
|
|
423
499
|
}
|
|
424
500
|
export type GqlHeavyOperation = {
|
|
425
|
-
base: Scalars['U64'];
|
|
426
|
-
gasPerUnit: Scalars['U64'];
|
|
501
|
+
base: Scalars['U64']['output'];
|
|
502
|
+
gasPerUnit: Scalars['U64']['output'];
|
|
427
503
|
};
|
|
428
504
|
export type GqlInput = GqlInputCoin | GqlInputContract | GqlInputMessage;
|
|
429
505
|
export type GqlInputCoin = {
|
|
430
|
-
amount: Scalars['U64'];
|
|
431
|
-
assetId: Scalars['AssetId'];
|
|
432
|
-
owner: Scalars['Address'];
|
|
433
|
-
predicate: Scalars['HexString'];
|
|
434
|
-
predicateData: Scalars['HexString'];
|
|
435
|
-
predicateGasUsed: Scalars['U64'];
|
|
436
|
-
txPointer: Scalars['TxPointer'];
|
|
437
|
-
utxoId: Scalars['UtxoId'];
|
|
438
|
-
witnessIndex: Scalars['Int'];
|
|
506
|
+
amount: Scalars['U64']['output'];
|
|
507
|
+
assetId: Scalars['AssetId']['output'];
|
|
508
|
+
owner: Scalars['Address']['output'];
|
|
509
|
+
predicate: Scalars['HexString']['output'];
|
|
510
|
+
predicateData: Scalars['HexString']['output'];
|
|
511
|
+
predicateGasUsed: Scalars['U64']['output'];
|
|
512
|
+
txPointer: Scalars['TxPointer']['output'];
|
|
513
|
+
utxoId: Scalars['UtxoId']['output'];
|
|
514
|
+
witnessIndex: Scalars['Int']['output'];
|
|
439
515
|
};
|
|
440
516
|
export type GqlInputContract = {
|
|
441
|
-
balanceRoot: Scalars['Bytes32'];
|
|
442
|
-
contractId: Scalars['ContractId'];
|
|
443
|
-
stateRoot: Scalars['Bytes32'];
|
|
444
|
-
txPointer: Scalars['TxPointer'];
|
|
445
|
-
utxoId: Scalars['UtxoId'];
|
|
517
|
+
balanceRoot: Scalars['Bytes32']['output'];
|
|
518
|
+
contractId: Scalars['ContractId']['output'];
|
|
519
|
+
stateRoot: Scalars['Bytes32']['output'];
|
|
520
|
+
txPointer: Scalars['TxPointer']['output'];
|
|
521
|
+
utxoId: Scalars['UtxoId']['output'];
|
|
446
522
|
};
|
|
447
523
|
export type GqlInputMessage = {
|
|
448
|
-
amount: Scalars['U64'];
|
|
449
|
-
data: Scalars['HexString'];
|
|
450
|
-
nonce: Scalars['Nonce'];
|
|
451
|
-
predicate: Scalars['HexString'];
|
|
452
|
-
predicateData: Scalars['HexString'];
|
|
453
|
-
predicateGasUsed: Scalars['U64'];
|
|
454
|
-
recipient: Scalars['Address'];
|
|
455
|
-
sender: Scalars['Address'];
|
|
456
|
-
witnessIndex: Scalars['U16'];
|
|
524
|
+
amount: Scalars['U64']['output'];
|
|
525
|
+
data: Scalars['HexString']['output'];
|
|
526
|
+
nonce: Scalars['Nonce']['output'];
|
|
527
|
+
predicate: Scalars['HexString']['output'];
|
|
528
|
+
predicateData: Scalars['HexString']['output'];
|
|
529
|
+
predicateGasUsed: Scalars['U64']['output'];
|
|
530
|
+
recipient: Scalars['Address']['output'];
|
|
531
|
+
sender: Scalars['Address']['output'];
|
|
532
|
+
witnessIndex: Scalars['U16']['output'];
|
|
457
533
|
};
|
|
458
534
|
export type GqlLatestGasPrice = {
|
|
459
|
-
blockHeight: Scalars['U32'];
|
|
460
|
-
gasPrice: Scalars['U64'];
|
|
535
|
+
blockHeight: Scalars['U32']['output'];
|
|
536
|
+
gasPrice: Scalars['U64']['output'];
|
|
461
537
|
};
|
|
462
538
|
export type GqlLightOperation = {
|
|
463
|
-
base: Scalars['U64'];
|
|
464
|
-
unitsPerGas: Scalars['U64'];
|
|
539
|
+
base: Scalars['U64']['output'];
|
|
540
|
+
unitsPerGas: Scalars['U64']['output'];
|
|
465
541
|
};
|
|
466
542
|
export type GqlMerkleProof = {
|
|
467
|
-
proofIndex: Scalars['U64'];
|
|
468
|
-
proofSet: Array<Scalars['Bytes32']>;
|
|
543
|
+
proofIndex: Scalars['U64']['output'];
|
|
544
|
+
proofSet: Array<Scalars['Bytes32']['output']>;
|
|
469
545
|
};
|
|
470
546
|
export type GqlMessage = {
|
|
471
|
-
amount: Scalars['U64'];
|
|
472
|
-
daHeight: Scalars['U64'];
|
|
473
|
-
data: Scalars['HexString'];
|
|
474
|
-
nonce: Scalars['Nonce'];
|
|
475
|
-
recipient: Scalars['Address'];
|
|
476
|
-
sender: Scalars['Address'];
|
|
547
|
+
amount: Scalars['U64']['output'];
|
|
548
|
+
daHeight: Scalars['U64']['output'];
|
|
549
|
+
data: Scalars['HexString']['output'];
|
|
550
|
+
nonce: Scalars['Nonce']['output'];
|
|
551
|
+
recipient: Scalars['Address']['output'];
|
|
552
|
+
sender: Scalars['Address']['output'];
|
|
477
553
|
};
|
|
478
554
|
export type GqlMessageCoin = {
|
|
479
|
-
amount: Scalars['U64'];
|
|
480
|
-
assetId: Scalars['AssetId'];
|
|
481
|
-
daHeight: Scalars['U64'];
|
|
482
|
-
nonce: Scalars['Nonce'];
|
|
483
|
-
recipient: Scalars['Address'];
|
|
484
|
-
sender: Scalars['Address'];
|
|
555
|
+
amount: Scalars['U64']['output'];
|
|
556
|
+
assetId: Scalars['AssetId']['output'];
|
|
557
|
+
daHeight: Scalars['U64']['output'];
|
|
558
|
+
nonce: Scalars['Nonce']['output'];
|
|
559
|
+
recipient: Scalars['Address']['output'];
|
|
560
|
+
sender: Scalars['Address']['output'];
|
|
485
561
|
};
|
|
486
562
|
export type GqlMessageConnection = {
|
|
487
563
|
/** A list of edges. */
|
|
@@ -494,20 +570,20 @@ export type GqlMessageConnection = {
|
|
|
494
570
|
/** An edge in a connection. */
|
|
495
571
|
export type GqlMessageEdge = {
|
|
496
572
|
/** A cursor for use in pagination */
|
|
497
|
-
cursor: Scalars['String'];
|
|
573
|
+
cursor: Scalars['String']['output'];
|
|
498
574
|
/** The item at the end of the edge */
|
|
499
575
|
node: GqlMessage;
|
|
500
576
|
};
|
|
501
577
|
export type GqlMessageProof = {
|
|
502
|
-
amount: Scalars['U64'];
|
|
578
|
+
amount: Scalars['U64']['output'];
|
|
503
579
|
blockProof: GqlMerkleProof;
|
|
504
580
|
commitBlockHeader: GqlHeader;
|
|
505
|
-
data: Scalars['HexString'];
|
|
581
|
+
data: Scalars['HexString']['output'];
|
|
506
582
|
messageBlockHeader: GqlHeader;
|
|
507
583
|
messageProof: GqlMerkleProof;
|
|
508
|
-
nonce: Scalars['Nonce'];
|
|
509
|
-
recipient: Scalars['Address'];
|
|
510
|
-
sender: Scalars['Address'];
|
|
584
|
+
nonce: Scalars['Nonce']['output'];
|
|
585
|
+
recipient: Scalars['Address']['output'];
|
|
586
|
+
sender: Scalars['Address']['output'];
|
|
511
587
|
};
|
|
512
588
|
export declare enum GqlMessageState {
|
|
513
589
|
NotFound = "NOT_FOUND",
|
|
@@ -526,29 +602,29 @@ export type GqlMutation = {
|
|
|
526
602
|
/** Execute a dry-run of multiple transactions using a fork of current state, no changes are committed. */
|
|
527
603
|
dryRun: Array<GqlDryRunTransactionExecutionStatus>;
|
|
528
604
|
/** End debugger session. */
|
|
529
|
-
endSession: Scalars['Boolean'];
|
|
605
|
+
endSession: Scalars['Boolean']['output'];
|
|
530
606
|
/** Execute a single fuel-asm instruction. */
|
|
531
|
-
execute: Scalars['Boolean'];
|
|
607
|
+
execute: Scalars['Boolean']['output'];
|
|
532
608
|
/**
|
|
533
609
|
* Sequentially produces `blocks_to_produce` blocks. The first block starts with
|
|
534
610
|
* `start_timestamp`. If the block production in the [`crate::service::Config`] is
|
|
535
611
|
* `Trigger::Interval { block_time }`, produces blocks with `block_time ` intervals between
|
|
536
612
|
* them. The `start_timestamp` is the timestamp in seconds.
|
|
537
613
|
*/
|
|
538
|
-
produceBlocks: Scalars['U32'];
|
|
614
|
+
produceBlocks: Scalars['U32']['output'];
|
|
539
615
|
/** Reset the VM instance to the initial state. */
|
|
540
|
-
reset: Scalars['Boolean'];
|
|
616
|
+
reset: Scalars['Boolean']['output'];
|
|
541
617
|
/** Set a breakpoint for a VM instance. */
|
|
542
|
-
setBreakpoint: Scalars['Boolean'];
|
|
618
|
+
setBreakpoint: Scalars['Boolean']['output'];
|
|
543
619
|
/** Set single-stepping mode for the VM instance. */
|
|
544
|
-
setSingleStepping: Scalars['Boolean'];
|
|
620
|
+
setSingleStepping: Scalars['Boolean']['output'];
|
|
545
621
|
/**
|
|
546
622
|
* Initialize a new debugger session, returning its ID.
|
|
547
623
|
* A new VM instance is spawned for each session.
|
|
548
624
|
* The session is run in a separate database transaction,
|
|
549
625
|
* on top of the most recent node state.
|
|
550
626
|
*/
|
|
551
|
-
startSession: Scalars['ID'];
|
|
627
|
+
startSession: Scalars['ID']['output'];
|
|
552
628
|
/**
|
|
553
629
|
* Run a single transaction in given session until it
|
|
554
630
|
* hits a breakpoint or completes.
|
|
@@ -562,49 +638,49 @@ export type GqlMutation = {
|
|
|
562
638
|
submit: GqlTransaction;
|
|
563
639
|
};
|
|
564
640
|
export type GqlMutationContinueTxArgs = {
|
|
565
|
-
id: Scalars['ID'];
|
|
641
|
+
id: Scalars['ID']['input'];
|
|
566
642
|
};
|
|
567
643
|
export type GqlMutationDryRunArgs = {
|
|
568
|
-
gasPrice?: InputMaybe<Scalars['U64']>;
|
|
569
|
-
txs: Array<Scalars['HexString']>;
|
|
570
|
-
utxoValidation?: InputMaybe<Scalars['Boolean']>;
|
|
644
|
+
gasPrice?: InputMaybe<Scalars['U64']['input']>;
|
|
645
|
+
txs: Array<Scalars['HexString']['input']>;
|
|
646
|
+
utxoValidation?: InputMaybe<Scalars['Boolean']['input']>;
|
|
571
647
|
};
|
|
572
648
|
export type GqlMutationEndSessionArgs = {
|
|
573
|
-
id: Scalars['ID'];
|
|
649
|
+
id: Scalars['ID']['input'];
|
|
574
650
|
};
|
|
575
651
|
export type GqlMutationExecuteArgs = {
|
|
576
|
-
id: Scalars['ID'];
|
|
577
|
-
op: Scalars['String'];
|
|
652
|
+
id: Scalars['ID']['input'];
|
|
653
|
+
op: Scalars['String']['input'];
|
|
578
654
|
};
|
|
579
655
|
export type GqlMutationProduceBlocksArgs = {
|
|
580
|
-
blocksToProduce: Scalars['U32'];
|
|
581
|
-
startTimestamp?: InputMaybe<Scalars['Tai64Timestamp']>;
|
|
656
|
+
blocksToProduce: Scalars['U32']['input'];
|
|
657
|
+
startTimestamp?: InputMaybe<Scalars['Tai64Timestamp']['input']>;
|
|
582
658
|
};
|
|
583
659
|
export type GqlMutationResetArgs = {
|
|
584
|
-
id: Scalars['ID'];
|
|
660
|
+
id: Scalars['ID']['input'];
|
|
585
661
|
};
|
|
586
662
|
export type GqlMutationSetBreakpointArgs = {
|
|
587
663
|
breakpoint: GqlBreakpoint;
|
|
588
|
-
id: Scalars['ID'];
|
|
664
|
+
id: Scalars['ID']['input'];
|
|
589
665
|
};
|
|
590
666
|
export type GqlMutationSetSingleSteppingArgs = {
|
|
591
|
-
enable: Scalars['Boolean'];
|
|
592
|
-
id: Scalars['ID'];
|
|
667
|
+
enable: Scalars['Boolean']['input'];
|
|
668
|
+
id: Scalars['ID']['input'];
|
|
593
669
|
};
|
|
594
670
|
export type GqlMutationStartTxArgs = {
|
|
595
|
-
id: Scalars['ID'];
|
|
596
|
-
txJson: Scalars['String'];
|
|
671
|
+
id: Scalars['ID']['input'];
|
|
672
|
+
txJson: Scalars['String']['input'];
|
|
597
673
|
};
|
|
598
674
|
export type GqlMutationSubmitArgs = {
|
|
599
|
-
tx: Scalars['HexString'];
|
|
675
|
+
tx: Scalars['HexString']['input'];
|
|
600
676
|
};
|
|
601
677
|
export type GqlNodeInfo = {
|
|
602
|
-
maxDepth: Scalars['U64'];
|
|
603
|
-
maxTx: Scalars['U64'];
|
|
604
|
-
nodeVersion: Scalars['String'];
|
|
678
|
+
maxDepth: Scalars['U64']['output'];
|
|
679
|
+
maxTx: Scalars['U64']['output'];
|
|
680
|
+
nodeVersion: Scalars['String']['output'];
|
|
605
681
|
peers: Array<GqlPeerInfo>;
|
|
606
|
-
utxoValidation: Scalars['Boolean'];
|
|
607
|
-
vmBacktrace: Scalars['Boolean'];
|
|
682
|
+
utxoValidation: Scalars['Boolean']['output'];
|
|
683
|
+
vmBacktrace: Scalars['Boolean']['output'];
|
|
608
684
|
};
|
|
609
685
|
export type GqlOutput = GqlChangeOutput | GqlCoinOutput | GqlContractCreated | GqlContractOutput | GqlVariableOutput;
|
|
610
686
|
/**
|
|
@@ -612,56 +688,56 @@ export type GqlOutput = GqlChangeOutput | GqlCoinOutput | GqlContractCreated | G
|
|
|
612
688
|
* type cannot act as both input and output type in async-graphql
|
|
613
689
|
*/
|
|
614
690
|
export type GqlOutputBreakpoint = {
|
|
615
|
-
contract: Scalars['ContractId'];
|
|
616
|
-
pc: Scalars['U64'];
|
|
691
|
+
contract: Scalars['ContractId']['output'];
|
|
692
|
+
pc: Scalars['U64']['output'];
|
|
617
693
|
};
|
|
618
694
|
/** Information about pagination in a connection */
|
|
619
695
|
export type GqlPageInfo = {
|
|
620
696
|
/** When paginating forwards, the cursor to continue. */
|
|
621
|
-
endCursor?: Maybe<Scalars['String']>;
|
|
697
|
+
endCursor?: Maybe<Scalars['String']['output']>;
|
|
622
698
|
/** When paginating forwards, are there more items? */
|
|
623
|
-
hasNextPage: Scalars['Boolean'];
|
|
699
|
+
hasNextPage: Scalars['Boolean']['output'];
|
|
624
700
|
/** When paginating backwards, are there more items? */
|
|
625
|
-
hasPreviousPage: Scalars['Boolean'];
|
|
701
|
+
hasPreviousPage: Scalars['Boolean']['output'];
|
|
626
702
|
/** When paginating backwards, the cursor to continue. */
|
|
627
|
-
startCursor?: Maybe<Scalars['String']>;
|
|
703
|
+
startCursor?: Maybe<Scalars['String']['output']>;
|
|
628
704
|
};
|
|
629
705
|
export type GqlPeerInfo = {
|
|
630
706
|
/** The advertised multi-addrs that can be used to connect to this peer */
|
|
631
|
-
addresses: Array<Scalars['String']>;
|
|
707
|
+
addresses: Array<Scalars['String']['output']>;
|
|
632
708
|
/** The internal fuel p2p reputation of this peer */
|
|
633
|
-
appScore: Scalars['Float'];
|
|
709
|
+
appScore: Scalars['Float']['output'];
|
|
634
710
|
/** The last reported height of the peer */
|
|
635
|
-
blockHeight?: Maybe<Scalars['U32']>;
|
|
711
|
+
blockHeight?: Maybe<Scalars['U32']['output']>;
|
|
636
712
|
/** The self-reported version of the client the peer is using */
|
|
637
|
-
clientVersion?: Maybe<Scalars['String']>;
|
|
713
|
+
clientVersion?: Maybe<Scalars['String']['output']>;
|
|
638
714
|
/** The libp2p peer id */
|
|
639
|
-
id: Scalars['String'];
|
|
715
|
+
id: Scalars['String']['output'];
|
|
640
716
|
/** The last heartbeat from this peer in unix epoch time ms */
|
|
641
|
-
lastHeartbeatMs: Scalars['U64'];
|
|
717
|
+
lastHeartbeatMs: Scalars['U64']['output'];
|
|
642
718
|
};
|
|
643
719
|
export type GqlPoAConsensus = {
|
|
644
720
|
/** Gets the signature of the block produced by `PoA` consensus. */
|
|
645
|
-
signature: Scalars['Signature'];
|
|
721
|
+
signature: Scalars['Signature']['output'];
|
|
646
722
|
};
|
|
647
723
|
export type GqlPolicies = {
|
|
648
|
-
maturity?: Maybe<Scalars['U32']>;
|
|
649
|
-
maxFee?: Maybe<Scalars['U64']>;
|
|
650
|
-
tip?: Maybe<Scalars['U64']>;
|
|
651
|
-
witnessLimit?: Maybe<Scalars['U64']>;
|
|
724
|
+
maturity?: Maybe<Scalars['U32']['output']>;
|
|
725
|
+
maxFee?: Maybe<Scalars['U64']['output']>;
|
|
726
|
+
tip?: Maybe<Scalars['U64']['output']>;
|
|
727
|
+
witnessLimit?: Maybe<Scalars['U64']['output']>;
|
|
652
728
|
};
|
|
653
729
|
export type GqlPredicateParameters = {
|
|
654
|
-
maxGasPerPredicate: Scalars['U64'];
|
|
655
|
-
maxMessageDataLength: Scalars['U64'];
|
|
656
|
-
maxPredicateDataLength: Scalars['U64'];
|
|
657
|
-
maxPredicateLength: Scalars['U64'];
|
|
730
|
+
maxGasPerPredicate: Scalars['U64']['output'];
|
|
731
|
+
maxMessageDataLength: Scalars['U64']['output'];
|
|
732
|
+
maxPredicateDataLength: Scalars['U64']['output'];
|
|
733
|
+
maxPredicateLength: Scalars['U64']['output'];
|
|
658
734
|
version: GqlPredicateParametersVersion;
|
|
659
735
|
};
|
|
660
736
|
export declare enum GqlPredicateParametersVersion {
|
|
661
737
|
V1 = "V1"
|
|
662
738
|
}
|
|
663
739
|
export type GqlProgramState = {
|
|
664
|
-
data: Scalars['HexString'];
|
|
740
|
+
data: Scalars['HexString']['output'];
|
|
665
741
|
returnType: GqlReturnType;
|
|
666
742
|
};
|
|
667
743
|
export type GqlQuery = {
|
|
@@ -694,155 +770,155 @@ export type GqlQuery = {
|
|
|
694
770
|
/** Estimate the predicate gas for the provided transaction */
|
|
695
771
|
estimatePredicates: GqlTransaction;
|
|
696
772
|
/** Returns true when the GraphQL API is serving requests. */
|
|
697
|
-
health: Scalars['Boolean'];
|
|
773
|
+
health: Scalars['Boolean']['output'];
|
|
698
774
|
latestGasPrice: GqlLatestGasPrice;
|
|
699
775
|
/** Read read a range of memory bytes. */
|
|
700
|
-
memory: Scalars['String'];
|
|
776
|
+
memory: Scalars['String']['output'];
|
|
701
777
|
message?: Maybe<GqlMessage>;
|
|
702
778
|
messageProof?: Maybe<GqlMessageProof>;
|
|
703
779
|
messageStatus: GqlMessageStatus;
|
|
704
780
|
messages: GqlMessageConnection;
|
|
705
781
|
nodeInfo: GqlNodeInfo;
|
|
706
782
|
/** Read register value by index. */
|
|
707
|
-
register: Scalars['U64'];
|
|
783
|
+
register: Scalars['U64']['output'];
|
|
708
784
|
relayedTransactionStatus?: Maybe<GqlRelayedTransactionStatus>;
|
|
709
785
|
transaction?: Maybe<GqlTransaction>;
|
|
710
786
|
transactions: GqlTransactionConnection;
|
|
711
787
|
transactionsByOwner: GqlTransactionConnection;
|
|
712
788
|
};
|
|
713
789
|
export type GqlQueryBalanceArgs = {
|
|
714
|
-
assetId: Scalars['AssetId'];
|
|
715
|
-
owner: Scalars['Address'];
|
|
790
|
+
assetId: Scalars['AssetId']['input'];
|
|
791
|
+
owner: Scalars['Address']['input'];
|
|
716
792
|
};
|
|
717
793
|
export type GqlQueryBalancesArgs = {
|
|
718
|
-
after?: InputMaybe<Scalars['String']>;
|
|
719
|
-
before?: InputMaybe<Scalars['String']>;
|
|
794
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
795
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
720
796
|
filter: GqlBalanceFilterInput;
|
|
721
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
722
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
797
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
798
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
723
799
|
};
|
|
724
800
|
export type GqlQueryBlockArgs = {
|
|
725
|
-
height?: InputMaybe<Scalars['U32']>;
|
|
726
|
-
id?: InputMaybe<Scalars['BlockId']>;
|
|
801
|
+
height?: InputMaybe<Scalars['U32']['input']>;
|
|
802
|
+
id?: InputMaybe<Scalars['BlockId']['input']>;
|
|
727
803
|
};
|
|
728
804
|
export type GqlQueryBlocksArgs = {
|
|
729
|
-
after?: InputMaybe<Scalars['String']>;
|
|
730
|
-
before?: InputMaybe<Scalars['String']>;
|
|
731
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
732
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
805
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
806
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
807
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
808
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
733
809
|
};
|
|
734
810
|
export type GqlQueryCoinArgs = {
|
|
735
|
-
utxoId: Scalars['UtxoId'];
|
|
811
|
+
utxoId: Scalars['UtxoId']['input'];
|
|
736
812
|
};
|
|
737
813
|
export type GqlQueryCoinsArgs = {
|
|
738
|
-
after?: InputMaybe<Scalars['String']>;
|
|
739
|
-
before?: InputMaybe<Scalars['String']>;
|
|
814
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
815
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
740
816
|
filter: GqlCoinFilterInput;
|
|
741
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
742
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
817
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
818
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
743
819
|
};
|
|
744
820
|
export type GqlQueryCoinsToSpendArgs = {
|
|
745
821
|
excludedIds?: InputMaybe<GqlExcludeInput>;
|
|
746
|
-
owner: Scalars['Address'];
|
|
822
|
+
owner: Scalars['Address']['input'];
|
|
747
823
|
queryPerAsset: Array<GqlSpendQueryElementInput>;
|
|
748
824
|
};
|
|
749
825
|
export type GqlQueryContractArgs = {
|
|
750
|
-
id: Scalars['ContractId'];
|
|
826
|
+
id: Scalars['ContractId']['input'];
|
|
751
827
|
};
|
|
752
828
|
export type GqlQueryContractBalanceArgs = {
|
|
753
|
-
asset: Scalars['AssetId'];
|
|
754
|
-
contract: Scalars['ContractId'];
|
|
829
|
+
asset: Scalars['AssetId']['input'];
|
|
830
|
+
contract: Scalars['ContractId']['input'];
|
|
755
831
|
};
|
|
756
832
|
export type GqlQueryContractBalancesArgs = {
|
|
757
|
-
after?: InputMaybe<Scalars['String']>;
|
|
758
|
-
before?: InputMaybe<Scalars['String']>;
|
|
833
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
834
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
759
835
|
filter: GqlContractBalanceFilterInput;
|
|
760
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
761
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
836
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
837
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
762
838
|
};
|
|
763
839
|
export type GqlQueryEstimateGasPriceArgs = {
|
|
764
|
-
blockHorizon?: InputMaybe<Scalars['U32']>;
|
|
840
|
+
blockHorizon?: InputMaybe<Scalars['U32']['input']>;
|
|
765
841
|
};
|
|
766
842
|
export type GqlQueryEstimatePredicatesArgs = {
|
|
767
|
-
tx: Scalars['HexString'];
|
|
843
|
+
tx: Scalars['HexString']['input'];
|
|
768
844
|
};
|
|
769
845
|
export type GqlQueryMemoryArgs = {
|
|
770
|
-
id: Scalars['ID'];
|
|
771
|
-
size: Scalars['U32'];
|
|
772
|
-
start: Scalars['U32'];
|
|
846
|
+
id: Scalars['ID']['input'];
|
|
847
|
+
size: Scalars['U32']['input'];
|
|
848
|
+
start: Scalars['U32']['input'];
|
|
773
849
|
};
|
|
774
850
|
export type GqlQueryMessageArgs = {
|
|
775
|
-
nonce: Scalars['Nonce'];
|
|
851
|
+
nonce: Scalars['Nonce']['input'];
|
|
776
852
|
};
|
|
777
853
|
export type GqlQueryMessageProofArgs = {
|
|
778
|
-
commitBlockHeight?: InputMaybe<Scalars['U32']>;
|
|
779
|
-
commitBlockId?: InputMaybe<Scalars['BlockId']>;
|
|
780
|
-
nonce: Scalars['Nonce'];
|
|
781
|
-
transactionId: Scalars['TransactionId'];
|
|
854
|
+
commitBlockHeight?: InputMaybe<Scalars['U32']['input']>;
|
|
855
|
+
commitBlockId?: InputMaybe<Scalars['BlockId']['input']>;
|
|
856
|
+
nonce: Scalars['Nonce']['input'];
|
|
857
|
+
transactionId: Scalars['TransactionId']['input'];
|
|
782
858
|
};
|
|
783
859
|
export type GqlQueryMessageStatusArgs = {
|
|
784
|
-
nonce: Scalars['Nonce'];
|
|
860
|
+
nonce: Scalars['Nonce']['input'];
|
|
785
861
|
};
|
|
786
862
|
export type GqlQueryMessagesArgs = {
|
|
787
|
-
after?: InputMaybe<Scalars['String']>;
|
|
788
|
-
before?: InputMaybe<Scalars['String']>;
|
|
789
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
790
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
791
|
-
owner?: InputMaybe<Scalars['Address']>;
|
|
863
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
864
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
865
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
866
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
867
|
+
owner?: InputMaybe<Scalars['Address']['input']>;
|
|
792
868
|
};
|
|
793
869
|
export type GqlQueryRegisterArgs = {
|
|
794
|
-
id: Scalars['ID'];
|
|
795
|
-
register: Scalars['U32'];
|
|
870
|
+
id: Scalars['ID']['input'];
|
|
871
|
+
register: Scalars['U32']['input'];
|
|
796
872
|
};
|
|
797
873
|
export type GqlQueryRelayedTransactionStatusArgs = {
|
|
798
|
-
id: Scalars['RelayedTransactionId'];
|
|
874
|
+
id: Scalars['RelayedTransactionId']['input'];
|
|
799
875
|
};
|
|
800
876
|
export type GqlQueryTransactionArgs = {
|
|
801
|
-
id: Scalars['TransactionId'];
|
|
877
|
+
id: Scalars['TransactionId']['input'];
|
|
802
878
|
};
|
|
803
879
|
export type GqlQueryTransactionsArgs = {
|
|
804
|
-
after?: InputMaybe<Scalars['String']>;
|
|
805
|
-
before?: InputMaybe<Scalars['String']>;
|
|
806
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
807
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
880
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
881
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
882
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
883
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
808
884
|
};
|
|
809
885
|
export type GqlQueryTransactionsByOwnerArgs = {
|
|
810
|
-
after?: InputMaybe<Scalars['String']>;
|
|
811
|
-
before?: InputMaybe<Scalars['String']>;
|
|
812
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
813
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
814
|
-
owner: Scalars['Address'];
|
|
886
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
887
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
888
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
889
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
890
|
+
owner: Scalars['Address']['input'];
|
|
815
891
|
};
|
|
816
892
|
export type GqlReceipt = {
|
|
817
|
-
amount?: Maybe<Scalars['U64']>;
|
|
818
|
-
assetId?: Maybe<Scalars['AssetId']>;
|
|
893
|
+
amount?: Maybe<Scalars['U64']['output']>;
|
|
894
|
+
assetId?: Maybe<Scalars['AssetId']['output']>;
|
|
819
895
|
/** Set in the case of a Panic receipt to indicate a missing contract input id */
|
|
820
|
-
contractId?: Maybe<Scalars['ContractId']>;
|
|
821
|
-
data?: Maybe<Scalars['HexString']>;
|
|
822
|
-
digest?: Maybe<Scalars['Bytes32']>;
|
|
823
|
-
gas?: Maybe<Scalars['U64']>;
|
|
824
|
-
gasUsed?: Maybe<Scalars['U64']>;
|
|
825
|
-
id?: Maybe<Scalars['ContractId']>;
|
|
826
|
-
is?: Maybe<Scalars['U64']>;
|
|
827
|
-
len?: Maybe<Scalars['U64']>;
|
|
828
|
-
nonce?: Maybe<Scalars['Nonce']>;
|
|
829
|
-
param1?: Maybe<Scalars['U64']>;
|
|
830
|
-
param2?: Maybe<Scalars['U64']>;
|
|
831
|
-
pc?: Maybe<Scalars['U64']>;
|
|
832
|
-
ptr?: Maybe<Scalars['U64']>;
|
|
833
|
-
ra?: Maybe<Scalars['U64']>;
|
|
834
|
-
rb?: Maybe<Scalars['U64']>;
|
|
835
|
-
rc?: Maybe<Scalars['U64']>;
|
|
836
|
-
rd?: Maybe<Scalars['U64']>;
|
|
837
|
-
reason?: Maybe<Scalars['U64']>;
|
|
896
|
+
contractId?: Maybe<Scalars['ContractId']['output']>;
|
|
897
|
+
data?: Maybe<Scalars['HexString']['output']>;
|
|
898
|
+
digest?: Maybe<Scalars['Bytes32']['output']>;
|
|
899
|
+
gas?: Maybe<Scalars['U64']['output']>;
|
|
900
|
+
gasUsed?: Maybe<Scalars['U64']['output']>;
|
|
901
|
+
id?: Maybe<Scalars['ContractId']['output']>;
|
|
902
|
+
is?: Maybe<Scalars['U64']['output']>;
|
|
903
|
+
len?: Maybe<Scalars['U64']['output']>;
|
|
904
|
+
nonce?: Maybe<Scalars['Nonce']['output']>;
|
|
905
|
+
param1?: Maybe<Scalars['U64']['output']>;
|
|
906
|
+
param2?: Maybe<Scalars['U64']['output']>;
|
|
907
|
+
pc?: Maybe<Scalars['U64']['output']>;
|
|
908
|
+
ptr?: Maybe<Scalars['U64']['output']>;
|
|
909
|
+
ra?: Maybe<Scalars['U64']['output']>;
|
|
910
|
+
rb?: Maybe<Scalars['U64']['output']>;
|
|
911
|
+
rc?: Maybe<Scalars['U64']['output']>;
|
|
912
|
+
rd?: Maybe<Scalars['U64']['output']>;
|
|
913
|
+
reason?: Maybe<Scalars['U64']['output']>;
|
|
838
914
|
receiptType: GqlReceiptType;
|
|
839
|
-
recipient?: Maybe<Scalars['Address']>;
|
|
840
|
-
result?: Maybe<Scalars['U64']>;
|
|
841
|
-
sender?: Maybe<Scalars['Address']>;
|
|
842
|
-
subId?: Maybe<Scalars['Bytes32']>;
|
|
843
|
-
to?: Maybe<Scalars['ContractId']>;
|
|
844
|
-
toAddress?: Maybe<Scalars['Address']>;
|
|
845
|
-
val?: Maybe<Scalars['U64']>;
|
|
915
|
+
recipient?: Maybe<Scalars['Address']['output']>;
|
|
916
|
+
result?: Maybe<Scalars['U64']['output']>;
|
|
917
|
+
sender?: Maybe<Scalars['Address']['output']>;
|
|
918
|
+
subId?: Maybe<Scalars['Bytes32']['output']>;
|
|
919
|
+
to?: Maybe<Scalars['ContractId']['output']>;
|
|
920
|
+
toAddress?: Maybe<Scalars['Address']['output']>;
|
|
921
|
+
val?: Maybe<Scalars['U64']['output']>;
|
|
846
922
|
};
|
|
847
923
|
export declare enum GqlReceiptType {
|
|
848
924
|
Burn = "BURN",
|
|
@@ -860,8 +936,8 @@ export declare enum GqlReceiptType {
|
|
|
860
936
|
TransferOut = "TRANSFER_OUT"
|
|
861
937
|
}
|
|
862
938
|
export type GqlRelayedTransactionFailed = {
|
|
863
|
-
blockHeight: Scalars['U32'];
|
|
864
|
-
failure: Scalars['String'];
|
|
939
|
+
blockHeight: Scalars['U32']['output'];
|
|
940
|
+
failure: Scalars['String']['output'];
|
|
865
941
|
};
|
|
866
942
|
export type GqlRelayedTransactionStatus = GqlRelayedTransactionFailed;
|
|
867
943
|
export declare enum GqlReturnType {
|
|
@@ -871,7 +947,7 @@ export declare enum GqlReturnType {
|
|
|
871
947
|
}
|
|
872
948
|
export type GqlRunResult = {
|
|
873
949
|
breakpoint?: Maybe<GqlOutputBreakpoint>;
|
|
874
|
-
jsonReceipts: Array<Scalars['String']>;
|
|
950
|
+
jsonReceipts: Array<Scalars['String']['output']>;
|
|
875
951
|
state: GqlRunState;
|
|
876
952
|
};
|
|
877
953
|
export declare enum GqlRunState {
|
|
@@ -881,8 +957,8 @@ export declare enum GqlRunState {
|
|
|
881
957
|
Completed = "COMPLETED"
|
|
882
958
|
}
|
|
883
959
|
export type GqlScriptParameters = {
|
|
884
|
-
maxScriptDataLength: Scalars['U64'];
|
|
885
|
-
maxScriptLength: Scalars['U64'];
|
|
960
|
+
maxScriptDataLength: Scalars['U64']['output'];
|
|
961
|
+
maxScriptLength: Scalars['U64']['output'];
|
|
886
962
|
version: GqlScriptParametersVersion;
|
|
887
963
|
};
|
|
888
964
|
export declare enum GqlScriptParametersVersion {
|
|
@@ -890,20 +966,20 @@ export declare enum GqlScriptParametersVersion {
|
|
|
890
966
|
}
|
|
891
967
|
export type GqlSpendQueryElementInput = {
|
|
892
968
|
/** Target amount for the query. */
|
|
893
|
-
amount: Scalars['U64'];
|
|
969
|
+
amount: Scalars['U64']['input'];
|
|
894
970
|
/** Identifier of the asset to spend. */
|
|
895
|
-
assetId: Scalars['AssetId'];
|
|
971
|
+
assetId: Scalars['AssetId']['input'];
|
|
896
972
|
/** The maximum number of currencies for selection. */
|
|
897
|
-
max?: InputMaybe<Scalars['U32']>;
|
|
973
|
+
max?: InputMaybe<Scalars['U32']['input']>;
|
|
898
974
|
};
|
|
899
975
|
export type GqlSqueezedOutStatus = {
|
|
900
|
-
reason: Scalars['String'];
|
|
976
|
+
reason: Scalars['String']['output'];
|
|
901
977
|
};
|
|
902
978
|
export type GqlStateTransitionPurpose = {
|
|
903
|
-
root: Scalars['Bytes32'];
|
|
979
|
+
root: Scalars['Bytes32']['output'];
|
|
904
980
|
};
|
|
905
981
|
export type GqlSubmittedStatus = {
|
|
906
|
-
time: Scalars['Tai64Timestamp'];
|
|
982
|
+
time: Scalars['Tai64Timestamp']['output'];
|
|
907
983
|
};
|
|
908
984
|
export type GqlSubscription = {
|
|
909
985
|
/**
|
|
@@ -925,55 +1001,55 @@ export type GqlSubscription = {
|
|
|
925
1001
|
submitAndAwait: GqlTransactionStatus;
|
|
926
1002
|
};
|
|
927
1003
|
export type GqlSubscriptionStatusChangeArgs = {
|
|
928
|
-
id: Scalars['TransactionId'];
|
|
1004
|
+
id: Scalars['TransactionId']['input'];
|
|
929
1005
|
};
|
|
930
1006
|
export type GqlSubscriptionSubmitAndAwaitArgs = {
|
|
931
|
-
tx: Scalars['HexString'];
|
|
1007
|
+
tx: Scalars['HexString']['input'];
|
|
932
1008
|
};
|
|
933
1009
|
export type GqlSuccessStatus = {
|
|
934
1010
|
block: GqlBlock;
|
|
935
1011
|
programState?: Maybe<GqlProgramState>;
|
|
936
1012
|
receipts: Array<GqlReceipt>;
|
|
937
|
-
time: Scalars['Tai64Timestamp'];
|
|
938
|
-
totalFee: Scalars['U64'];
|
|
939
|
-
totalGas: Scalars['U64'];
|
|
940
|
-
transactionId: Scalars['TransactionId'];
|
|
1013
|
+
time: Scalars['Tai64Timestamp']['output'];
|
|
1014
|
+
totalFee: Scalars['U64']['output'];
|
|
1015
|
+
totalGas: Scalars['U64']['output'];
|
|
1016
|
+
transactionId: Scalars['TransactionId']['output'];
|
|
941
1017
|
};
|
|
942
1018
|
export type GqlTransaction = {
|
|
943
|
-
bytecodeRoot?: Maybe<Scalars['Bytes32']>;
|
|
944
|
-
bytecodeWitnessIndex?: Maybe<Scalars['U16']>;
|
|
945
|
-
id: Scalars['TransactionId'];
|
|
946
|
-
inputAssetIds?: Maybe<Array<Scalars['AssetId']>>;
|
|
1019
|
+
bytecodeRoot?: Maybe<Scalars['Bytes32']['output']>;
|
|
1020
|
+
bytecodeWitnessIndex?: Maybe<Scalars['U16']['output']>;
|
|
1021
|
+
id: Scalars['TransactionId']['output'];
|
|
1022
|
+
inputAssetIds?: Maybe<Array<Scalars['AssetId']['output']>>;
|
|
947
1023
|
inputContract?: Maybe<GqlInputContract>;
|
|
948
|
-
inputContracts?: Maybe<Array<Scalars['ContractId']>>;
|
|
1024
|
+
inputContracts?: Maybe<Array<Scalars['ContractId']['output']>>;
|
|
949
1025
|
inputs?: Maybe<Array<GqlInput>>;
|
|
950
|
-
isCreate: Scalars['Boolean'];
|
|
951
|
-
isMint: Scalars['Boolean'];
|
|
952
|
-
isScript: Scalars['Boolean'];
|
|
953
|
-
isUpgrade: Scalars['Boolean'];
|
|
954
|
-
isUpload: Scalars['Boolean'];
|
|
955
|
-
maturity?: Maybe<Scalars['U32']>;
|
|
956
|
-
mintAmount?: Maybe<Scalars['U64']>;
|
|
957
|
-
mintAssetId?: Maybe<Scalars['AssetId']>;
|
|
958
|
-
mintGasPrice?: Maybe<Scalars['U64']>;
|
|
1026
|
+
isCreate: Scalars['Boolean']['output'];
|
|
1027
|
+
isMint: Scalars['Boolean']['output'];
|
|
1028
|
+
isScript: Scalars['Boolean']['output'];
|
|
1029
|
+
isUpgrade: Scalars['Boolean']['output'];
|
|
1030
|
+
isUpload: Scalars['Boolean']['output'];
|
|
1031
|
+
maturity?: Maybe<Scalars['U32']['output']>;
|
|
1032
|
+
mintAmount?: Maybe<Scalars['U64']['output']>;
|
|
1033
|
+
mintAssetId?: Maybe<Scalars['AssetId']['output']>;
|
|
1034
|
+
mintGasPrice?: Maybe<Scalars['U64']['output']>;
|
|
959
1035
|
outputContract?: Maybe<GqlContractOutput>;
|
|
960
1036
|
outputs: Array<GqlOutput>;
|
|
961
1037
|
policies?: Maybe<GqlPolicies>;
|
|
962
|
-
proofSet?: Maybe<Array<Scalars['Bytes32']>>;
|
|
1038
|
+
proofSet?: Maybe<Array<Scalars['Bytes32']['output']>>;
|
|
963
1039
|
/** Return the transaction bytes using canonical encoding */
|
|
964
|
-
rawPayload: Scalars['HexString'];
|
|
965
|
-
receiptsRoot?: Maybe<Scalars['Bytes32']>;
|
|
966
|
-
salt?: Maybe<Scalars['Salt']>;
|
|
967
|
-
script?: Maybe<Scalars['HexString']>;
|
|
968
|
-
scriptData?: Maybe<Scalars['HexString']>;
|
|
969
|
-
scriptGasLimit?: Maybe<Scalars['U64']>;
|
|
1040
|
+
rawPayload: Scalars['HexString']['output'];
|
|
1041
|
+
receiptsRoot?: Maybe<Scalars['Bytes32']['output']>;
|
|
1042
|
+
salt?: Maybe<Scalars['Salt']['output']>;
|
|
1043
|
+
script?: Maybe<Scalars['HexString']['output']>;
|
|
1044
|
+
scriptData?: Maybe<Scalars['HexString']['output']>;
|
|
1045
|
+
scriptGasLimit?: Maybe<Scalars['U64']['output']>;
|
|
970
1046
|
status?: Maybe<GqlTransactionStatus>;
|
|
971
|
-
storageSlots?: Maybe<Array<Scalars['HexString']>>;
|
|
972
|
-
subsectionIndex?: Maybe<Scalars['U16']>;
|
|
973
|
-
subsectionsNumber?: Maybe<Scalars['U16']>;
|
|
974
|
-
txPointer?: Maybe<Scalars['TxPointer']>;
|
|
1047
|
+
storageSlots?: Maybe<Array<Scalars['HexString']['output']>>;
|
|
1048
|
+
subsectionIndex?: Maybe<Scalars['U16']['output']>;
|
|
1049
|
+
subsectionsNumber?: Maybe<Scalars['U16']['output']>;
|
|
1050
|
+
txPointer?: Maybe<Scalars['TxPointer']['output']>;
|
|
975
1051
|
upgradePurpose?: Maybe<GqlUpgradePurpose>;
|
|
976
|
-
witnesses?: Maybe<Array<Scalars['HexString']>>;
|
|
1052
|
+
witnesses?: Maybe<Array<Scalars['HexString']['output']>>;
|
|
977
1053
|
};
|
|
978
1054
|
export type GqlTransactionConnection = {
|
|
979
1055
|
/** A list of edges. */
|
|
@@ -986,18 +1062,18 @@ export type GqlTransactionConnection = {
|
|
|
986
1062
|
/** An edge in a connection. */
|
|
987
1063
|
export type GqlTransactionEdge = {
|
|
988
1064
|
/** A cursor for use in pagination */
|
|
989
|
-
cursor: Scalars['String'];
|
|
1065
|
+
cursor: Scalars['String']['output'];
|
|
990
1066
|
/** The item at the end of the edge */
|
|
991
1067
|
node: GqlTransaction;
|
|
992
1068
|
};
|
|
993
1069
|
export type GqlTransactionStatus = GqlFailureStatus | GqlSqueezedOutStatus | GqlSubmittedStatus | GqlSuccessStatus;
|
|
994
1070
|
export type GqlTxParameters = {
|
|
995
|
-
maxBytecodeSubsections: Scalars['U16'];
|
|
996
|
-
maxGasPerTx: Scalars['U64'];
|
|
997
|
-
maxInputs: Scalars['U16'];
|
|
998
|
-
maxOutputs: Scalars['U16'];
|
|
999
|
-
maxSize: Scalars['U64'];
|
|
1000
|
-
maxWitnesses: Scalars['U32'];
|
|
1071
|
+
maxBytecodeSubsections: Scalars['U16']['output'];
|
|
1072
|
+
maxGasPerTx: Scalars['U64']['output'];
|
|
1073
|
+
maxInputs: Scalars['U16']['output'];
|
|
1074
|
+
maxOutputs: Scalars['U16']['output'];
|
|
1075
|
+
maxSize: Scalars['U64']['output'];
|
|
1076
|
+
maxWitnesses: Scalars['U32']['output'];
|
|
1001
1077
|
version: GqlTxParametersVersion;
|
|
1002
1078
|
};
|
|
1003
1079
|
export declare enum GqlTxParametersVersion {
|
|
@@ -1005,9 +1081,9 @@ export declare enum GqlTxParametersVersion {
|
|
|
1005
1081
|
}
|
|
1006
1082
|
export type GqlUpgradePurpose = GqlConsensusParametersPurpose | GqlStateTransitionPurpose;
|
|
1007
1083
|
export type GqlVariableOutput = {
|
|
1008
|
-
amount: Scalars['U64'];
|
|
1009
|
-
assetId: Scalars['AssetId'];
|
|
1010
|
-
to: Scalars['Address'];
|
|
1084
|
+
amount: Scalars['U64']['output'];
|
|
1085
|
+
assetId: Scalars['AssetId']['output'];
|
|
1086
|
+
to: Scalars['Address']['output'];
|
|
1011
1087
|
};
|
|
1012
1088
|
export type GqlSubmittedStatusFragment = {
|
|
1013
1089
|
time: string;
|
|
@@ -1100,7 +1176,7 @@ export type GqlSqueezedOutStatusFragment = {
|
|
|
1100
1176
|
reason: string;
|
|
1101
1177
|
type: 'SqueezedOutStatus';
|
|
1102
1178
|
};
|
|
1103
|
-
type
|
|
1179
|
+
type GqlTransactionStatusFragment_FailureStatus = {
|
|
1104
1180
|
totalGas: string;
|
|
1105
1181
|
totalFee: string;
|
|
1106
1182
|
time: string;
|
|
@@ -1140,15 +1216,15 @@ type GqlTransactionStatusFragment_FailureStatus_ = {
|
|
|
1140
1216
|
subId?: string | null;
|
|
1141
1217
|
}>;
|
|
1142
1218
|
};
|
|
1143
|
-
type
|
|
1219
|
+
type GqlTransactionStatusFragment_SqueezedOutStatus = {
|
|
1144
1220
|
reason: string;
|
|
1145
1221
|
type: 'SqueezedOutStatus';
|
|
1146
1222
|
};
|
|
1147
|
-
type
|
|
1223
|
+
type GqlTransactionStatusFragment_SubmittedStatus = {
|
|
1148
1224
|
time: string;
|
|
1149
1225
|
type: 'SubmittedStatus';
|
|
1150
1226
|
};
|
|
1151
|
-
type
|
|
1227
|
+
type GqlTransactionStatusFragment_SuccessStatus = {
|
|
1152
1228
|
time: string;
|
|
1153
1229
|
totalGas: string;
|
|
1154
1230
|
totalFee: string;
|
|
@@ -1191,21 +1267,21 @@ type GqlTransactionStatusFragment_SuccessStatus_ = {
|
|
|
1191
1267
|
subId?: string | null;
|
|
1192
1268
|
}>;
|
|
1193
1269
|
};
|
|
1194
|
-
export type GqlTransactionStatusFragment =
|
|
1195
|
-
type
|
|
1270
|
+
export type GqlTransactionStatusFragment = GqlTransactionStatusFragment_FailureStatus | GqlTransactionStatusFragment_SqueezedOutStatus | GqlTransactionStatusFragment_SubmittedStatus | GqlTransactionStatusFragment_SuccessStatus;
|
|
1271
|
+
type GqlTransactionStatusSubscriptionFragment_FailureStatus = {
|
|
1196
1272
|
type: 'FailureStatus';
|
|
1197
1273
|
};
|
|
1198
|
-
type
|
|
1274
|
+
type GqlTransactionStatusSubscriptionFragment_SqueezedOutStatus = {
|
|
1199
1275
|
reason: string;
|
|
1200
1276
|
type: 'SqueezedOutStatus';
|
|
1201
1277
|
};
|
|
1202
|
-
type
|
|
1278
|
+
type GqlTransactionStatusSubscriptionFragment_SubmittedStatus = {
|
|
1203
1279
|
type: 'SubmittedStatus';
|
|
1204
1280
|
};
|
|
1205
|
-
type
|
|
1281
|
+
type GqlTransactionStatusSubscriptionFragment_SuccessStatus = {
|
|
1206
1282
|
type: 'SuccessStatus';
|
|
1207
1283
|
};
|
|
1208
|
-
export type GqlTransactionStatusSubscriptionFragment =
|
|
1284
|
+
export type GqlTransactionStatusSubscriptionFragment = GqlTransactionStatusSubscriptionFragment_FailureStatus | GqlTransactionStatusSubscriptionFragment_SqueezedOutStatus | GqlTransactionStatusSubscriptionFragment_SubmittedStatus | GqlTransactionStatusSubscriptionFragment_SuccessStatus;
|
|
1209
1285
|
export type GqlTransactionFragment = {
|
|
1210
1286
|
id: string;
|
|
1211
1287
|
rawPayload: string;
|
|
@@ -1298,14 +1374,14 @@ export type GqlTransactionFragment = {
|
|
|
1298
1374
|
}>;
|
|
1299
1375
|
} | null;
|
|
1300
1376
|
};
|
|
1301
|
-
type
|
|
1377
|
+
type GqlInputEstimatePredicatesFragment_InputCoin = {
|
|
1302
1378
|
predicateGasUsed: string;
|
|
1303
1379
|
};
|
|
1304
|
-
type
|
|
1305
|
-
type
|
|
1380
|
+
type GqlInputEstimatePredicatesFragment_InputContract = {};
|
|
1381
|
+
type GqlInputEstimatePredicatesFragment_InputMessage = {
|
|
1306
1382
|
predicateGasUsed: string;
|
|
1307
1383
|
};
|
|
1308
|
-
export type GqlInputEstimatePredicatesFragment =
|
|
1384
|
+
export type GqlInputEstimatePredicatesFragment = GqlInputEstimatePredicatesFragment_InputCoin | GqlInputEstimatePredicatesFragment_InputContract | GqlInputEstimatePredicatesFragment_InputMessage;
|
|
1309
1385
|
export type GqlTransactionEstimatePredicatesFragment = {
|
|
1310
1386
|
inputs?: Array<{
|
|
1311
1387
|
predicateGasUsed: string;
|
|
@@ -1362,7 +1438,7 @@ export type GqlReceiptFragment = {
|
|
|
1362
1438
|
contractId?: string | null;
|
|
1363
1439
|
subId?: string | null;
|
|
1364
1440
|
};
|
|
1365
|
-
type
|
|
1441
|
+
type GqlDryRunTransactionStatusFragment_DryRunFailureStatus = {
|
|
1366
1442
|
totalGas: string;
|
|
1367
1443
|
totalFee: string;
|
|
1368
1444
|
reason: string;
|
|
@@ -1372,7 +1448,7 @@ type GqlDryRunTransactionStatusFragment_DryRunFailureStatus_ = {
|
|
|
1372
1448
|
data: string;
|
|
1373
1449
|
} | null;
|
|
1374
1450
|
};
|
|
1375
|
-
type
|
|
1451
|
+
type GqlDryRunTransactionStatusFragment_DryRunSuccessStatus = {
|
|
1376
1452
|
totalGas: string;
|
|
1377
1453
|
totalFee: string;
|
|
1378
1454
|
type: 'DryRunSuccessStatus';
|
|
@@ -1381,7 +1457,7 @@ type GqlDryRunTransactionStatusFragment_DryRunSuccessStatus_ = {
|
|
|
1381
1457
|
data: string;
|
|
1382
1458
|
} | null;
|
|
1383
1459
|
};
|
|
1384
|
-
export type GqlDryRunTransactionStatusFragment =
|
|
1460
|
+
export type GqlDryRunTransactionStatusFragment = GqlDryRunTransactionStatusFragment_DryRunFailureStatus | GqlDryRunTransactionStatusFragment_DryRunSuccessStatus;
|
|
1385
1461
|
export type GqlDryRunTransactionExecutionStatusFragment = {
|
|
1386
1462
|
id: string;
|
|
1387
1463
|
status: {
|
|
@@ -1552,17 +1628,17 @@ export type GqlFeeParametersFragment = {
|
|
|
1552
1628
|
gasPriceFactor: string;
|
|
1553
1629
|
gasPerByte: string;
|
|
1554
1630
|
};
|
|
1555
|
-
type
|
|
1631
|
+
type GqlDependentCostFragment_HeavyOperation = {
|
|
1556
1632
|
base: string;
|
|
1557
1633
|
gasPerUnit: string;
|
|
1558
1634
|
type: 'HeavyOperation';
|
|
1559
1635
|
};
|
|
1560
|
-
type
|
|
1636
|
+
type GqlDependentCostFragment_LightOperation = {
|
|
1561
1637
|
base: string;
|
|
1562
1638
|
unitsPerGas: string;
|
|
1563
1639
|
type: 'LightOperation';
|
|
1564
1640
|
};
|
|
1565
|
-
export type GqlDependentCostFragment =
|
|
1641
|
+
export type GqlDependentCostFragment = GqlDependentCostFragment_HeavyOperation | GqlDependentCostFragment_LightOperation;
|
|
1566
1642
|
export type GqlGasCostsFragment = {
|
|
1567
1643
|
version: GqlGasCostsVersion;
|
|
1568
1644
|
add: string;
|
|
@@ -1663,6 +1739,24 @@ export type GqlGasCostsFragment = {
|
|
|
1663
1739
|
unitsPerGas: string;
|
|
1664
1740
|
type: 'LightOperation';
|
|
1665
1741
|
};
|
|
1742
|
+
cfe: {
|
|
1743
|
+
base: string;
|
|
1744
|
+
gasPerUnit: string;
|
|
1745
|
+
type: 'HeavyOperation';
|
|
1746
|
+
} | {
|
|
1747
|
+
base: string;
|
|
1748
|
+
unitsPerGas: string;
|
|
1749
|
+
type: 'LightOperation';
|
|
1750
|
+
};
|
|
1751
|
+
cfeiDependentCost: {
|
|
1752
|
+
base: string;
|
|
1753
|
+
gasPerUnit: string;
|
|
1754
|
+
type: 'HeavyOperation';
|
|
1755
|
+
} | {
|
|
1756
|
+
base: string;
|
|
1757
|
+
unitsPerGas: string;
|
|
1758
|
+
type: 'LightOperation';
|
|
1759
|
+
};
|
|
1666
1760
|
call: {
|
|
1667
1761
|
base: string;
|
|
1668
1762
|
gasPerUnit: string;
|
|
@@ -1988,6 +2082,24 @@ export type GqlConsensusParametersFragment = {
|
|
|
1988
2082
|
unitsPerGas: string;
|
|
1989
2083
|
type: 'LightOperation';
|
|
1990
2084
|
};
|
|
2085
|
+
cfe: {
|
|
2086
|
+
base: string;
|
|
2087
|
+
gasPerUnit: string;
|
|
2088
|
+
type: 'HeavyOperation';
|
|
2089
|
+
} | {
|
|
2090
|
+
base: string;
|
|
2091
|
+
unitsPerGas: string;
|
|
2092
|
+
type: 'LightOperation';
|
|
2093
|
+
};
|
|
2094
|
+
cfeiDependentCost: {
|
|
2095
|
+
base: string;
|
|
2096
|
+
gasPerUnit: string;
|
|
2097
|
+
type: 'HeavyOperation';
|
|
2098
|
+
} | {
|
|
2099
|
+
base: string;
|
|
2100
|
+
unitsPerGas: string;
|
|
2101
|
+
type: 'LightOperation';
|
|
2102
|
+
};
|
|
1991
2103
|
call: {
|
|
1992
2104
|
base: string;
|
|
1993
2105
|
gasPerUnit: string;
|
|
@@ -2327,6 +2439,24 @@ export type GqlChainInfoFragment = {
|
|
|
2327
2439
|
unitsPerGas: string;
|
|
2328
2440
|
type: 'LightOperation';
|
|
2329
2441
|
};
|
|
2442
|
+
cfe: {
|
|
2443
|
+
base: string;
|
|
2444
|
+
gasPerUnit: string;
|
|
2445
|
+
type: 'HeavyOperation';
|
|
2446
|
+
} | {
|
|
2447
|
+
base: string;
|
|
2448
|
+
unitsPerGas: string;
|
|
2449
|
+
type: 'LightOperation';
|
|
2450
|
+
};
|
|
2451
|
+
cfeiDependentCost: {
|
|
2452
|
+
base: string;
|
|
2453
|
+
gasPerUnit: string;
|
|
2454
|
+
type: 'HeavyOperation';
|
|
2455
|
+
} | {
|
|
2456
|
+
base: string;
|
|
2457
|
+
unitsPerGas: string;
|
|
2458
|
+
type: 'LightOperation';
|
|
2459
|
+
};
|
|
2330
2460
|
call: {
|
|
2331
2461
|
base: string;
|
|
2332
2462
|
gasPerUnit: string;
|
|
@@ -2713,6 +2843,24 @@ export type GqlGetChainQuery = {
|
|
|
2713
2843
|
unitsPerGas: string;
|
|
2714
2844
|
type: 'LightOperation';
|
|
2715
2845
|
};
|
|
2846
|
+
cfe: {
|
|
2847
|
+
base: string;
|
|
2848
|
+
gasPerUnit: string;
|
|
2849
|
+
type: 'HeavyOperation';
|
|
2850
|
+
} | {
|
|
2851
|
+
base: string;
|
|
2852
|
+
unitsPerGas: string;
|
|
2853
|
+
type: 'LightOperation';
|
|
2854
|
+
};
|
|
2855
|
+
cfeiDependentCost: {
|
|
2856
|
+
base: string;
|
|
2857
|
+
gasPerUnit: string;
|
|
2858
|
+
type: 'HeavyOperation';
|
|
2859
|
+
} | {
|
|
2860
|
+
base: string;
|
|
2861
|
+
unitsPerGas: string;
|
|
2862
|
+
type: 'LightOperation';
|
|
2863
|
+
};
|
|
2716
2864
|
call: {
|
|
2717
2865
|
base: string;
|
|
2718
2866
|
gasPerUnit: string;
|
|
@@ -2907,7 +3055,7 @@ export type GqlGetChainQuery = {
|
|
|
2907
3055
|
};
|
|
2908
3056
|
};
|
|
2909
3057
|
export type GqlGetTransactionQueryVariables = Exact<{
|
|
2910
|
-
transactionId: Scalars['TransactionId'];
|
|
3058
|
+
transactionId: Scalars['TransactionId']['input'];
|
|
2911
3059
|
}>;
|
|
2912
3060
|
export type GqlGetTransactionQuery = {
|
|
2913
3061
|
transaction?: {
|
|
@@ -3004,7 +3152,7 @@ export type GqlGetTransactionQuery = {
|
|
|
3004
3152
|
} | null;
|
|
3005
3153
|
};
|
|
3006
3154
|
export type GqlGetTransactionWithReceiptsQueryVariables = Exact<{
|
|
3007
|
-
transactionId: Scalars['TransactionId'];
|
|
3155
|
+
transactionId: Scalars['TransactionId']['input'];
|
|
3008
3156
|
}>;
|
|
3009
3157
|
export type GqlGetTransactionWithReceiptsQuery = {
|
|
3010
3158
|
transaction?: {
|
|
@@ -3101,10 +3249,10 @@ export type GqlGetTransactionWithReceiptsQuery = {
|
|
|
3101
3249
|
} | null;
|
|
3102
3250
|
};
|
|
3103
3251
|
export type GqlGetTransactionsQueryVariables = Exact<{
|
|
3104
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3105
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3106
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3107
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3252
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3253
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3254
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3255
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3108
3256
|
}>;
|
|
3109
3257
|
export type GqlGetTransactionsQuery = {
|
|
3110
3258
|
transactions: {
|
|
@@ -3211,11 +3359,11 @@ export type GqlGetTransactionsQuery = {
|
|
|
3211
3359
|
};
|
|
3212
3360
|
};
|
|
3213
3361
|
export type GqlGetTransactionsByOwnerQueryVariables = Exact<{
|
|
3214
|
-
owner: Scalars['Address'];
|
|
3215
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3216
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3217
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3218
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3362
|
+
owner: Scalars['Address']['input'];
|
|
3363
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3364
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3365
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3366
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3219
3367
|
}>;
|
|
3220
3368
|
export type GqlGetTransactionsByOwnerQuery = {
|
|
3221
3369
|
transactionsByOwner: {
|
|
@@ -3322,7 +3470,7 @@ export type GqlGetTransactionsByOwnerQuery = {
|
|
|
3322
3470
|
};
|
|
3323
3471
|
};
|
|
3324
3472
|
export type GqlEstimatePredicatesQueryVariables = Exact<{
|
|
3325
|
-
encodedTransaction: Scalars['HexString'];
|
|
3473
|
+
encodedTransaction: Scalars['HexString']['input'];
|
|
3326
3474
|
}>;
|
|
3327
3475
|
export type GqlEstimatePredicatesQuery = {
|
|
3328
3476
|
estimatePredicates: {
|
|
@@ -3334,8 +3482,8 @@ export type GqlEstimatePredicatesQuery = {
|
|
|
3334
3482
|
};
|
|
3335
3483
|
};
|
|
3336
3484
|
export type GqlGetBlockQueryVariables = Exact<{
|
|
3337
|
-
blockId?: InputMaybe<Scalars['BlockId']>;
|
|
3338
|
-
height?: InputMaybe<Scalars['U32']>;
|
|
3485
|
+
blockId?: InputMaybe<Scalars['BlockId']['input']>;
|
|
3486
|
+
height?: InputMaybe<Scalars['U32']['input']>;
|
|
3339
3487
|
}>;
|
|
3340
3488
|
export type GqlGetBlockQuery = {
|
|
3341
3489
|
block?: {
|
|
@@ -3350,8 +3498,8 @@ export type GqlGetBlockQuery = {
|
|
|
3350
3498
|
} | null;
|
|
3351
3499
|
};
|
|
3352
3500
|
export type GqlGetBlockWithTransactionsQueryVariables = Exact<{
|
|
3353
|
-
blockId?: InputMaybe<Scalars['BlockId']>;
|
|
3354
|
-
blockHeight?: InputMaybe<Scalars['U32']>;
|
|
3501
|
+
blockId?: InputMaybe<Scalars['BlockId']['input']>;
|
|
3502
|
+
blockHeight?: InputMaybe<Scalars['U32']['input']>;
|
|
3355
3503
|
}>;
|
|
3356
3504
|
export type GqlGetBlockWithTransactionsQuery = {
|
|
3357
3505
|
block?: {
|
|
@@ -3455,10 +3603,10 @@ export type GqlGetBlockWithTransactionsQuery = {
|
|
|
3455
3603
|
} | null;
|
|
3456
3604
|
};
|
|
3457
3605
|
export type GqlGetBlocksQueryVariables = Exact<{
|
|
3458
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3459
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3460
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3461
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3606
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3607
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3608
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3609
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3462
3610
|
}>;
|
|
3463
3611
|
export type GqlGetBlocksQuery = {
|
|
3464
3612
|
blocks: {
|
|
@@ -3477,7 +3625,7 @@ export type GqlGetBlocksQuery = {
|
|
|
3477
3625
|
};
|
|
3478
3626
|
};
|
|
3479
3627
|
export type GqlGetCoinQueryVariables = Exact<{
|
|
3480
|
-
coinId: Scalars['UtxoId'];
|
|
3628
|
+
coinId: Scalars['UtxoId']['input'];
|
|
3481
3629
|
}>;
|
|
3482
3630
|
export type GqlGetCoinQuery = {
|
|
3483
3631
|
coin?: {
|
|
@@ -3492,10 +3640,10 @@ export type GqlGetCoinQuery = {
|
|
|
3492
3640
|
};
|
|
3493
3641
|
export type GqlGetCoinsQueryVariables = Exact<{
|
|
3494
3642
|
filter: GqlCoinFilterInput;
|
|
3495
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3496
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3497
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3498
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3643
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3644
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3645
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3646
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3499
3647
|
}>;
|
|
3500
3648
|
export type GqlGetCoinsQuery = {
|
|
3501
3649
|
coins: {
|
|
@@ -3513,7 +3661,7 @@ export type GqlGetCoinsQuery = {
|
|
|
3513
3661
|
};
|
|
3514
3662
|
};
|
|
3515
3663
|
export type GqlGetCoinsToSpendQueryVariables = Exact<{
|
|
3516
|
-
owner: Scalars['Address'];
|
|
3664
|
+
owner: Scalars['Address']['input'];
|
|
3517
3665
|
queryPerAsset: Array<GqlSpendQueryElementInput> | GqlSpendQueryElementInput;
|
|
3518
3666
|
excludedIds?: InputMaybe<GqlExcludeInput>;
|
|
3519
3667
|
}>;
|
|
@@ -3537,7 +3685,7 @@ export type GqlGetCoinsToSpendQuery = {
|
|
|
3537
3685
|
}>>;
|
|
3538
3686
|
};
|
|
3539
3687
|
export type GqlGetContractQueryVariables = Exact<{
|
|
3540
|
-
contractId: Scalars['ContractId'];
|
|
3688
|
+
contractId: Scalars['ContractId']['input'];
|
|
3541
3689
|
}>;
|
|
3542
3690
|
export type GqlGetContractQuery = {
|
|
3543
3691
|
contract?: {
|
|
@@ -3546,8 +3694,8 @@ export type GqlGetContractQuery = {
|
|
|
3546
3694
|
} | null;
|
|
3547
3695
|
};
|
|
3548
3696
|
export type GqlGetContractBalanceQueryVariables = Exact<{
|
|
3549
|
-
contract: Scalars['ContractId'];
|
|
3550
|
-
asset: Scalars['AssetId'];
|
|
3697
|
+
contract: Scalars['ContractId']['input'];
|
|
3698
|
+
asset: Scalars['AssetId']['input'];
|
|
3551
3699
|
}>;
|
|
3552
3700
|
export type GqlGetContractBalanceQuery = {
|
|
3553
3701
|
contractBalance: {
|
|
@@ -3557,8 +3705,8 @@ export type GqlGetContractBalanceQuery = {
|
|
|
3557
3705
|
};
|
|
3558
3706
|
};
|
|
3559
3707
|
export type GqlGetBalanceQueryVariables = Exact<{
|
|
3560
|
-
owner: Scalars['Address'];
|
|
3561
|
-
assetId: Scalars['AssetId'];
|
|
3708
|
+
owner: Scalars['Address']['input'];
|
|
3709
|
+
assetId: Scalars['AssetId']['input'];
|
|
3562
3710
|
}>;
|
|
3563
3711
|
export type GqlGetBalanceQuery = {
|
|
3564
3712
|
balance: {
|
|
@@ -3576,7 +3724,7 @@ export type GqlGetLatestGasPriceQuery = {
|
|
|
3576
3724
|
};
|
|
3577
3725
|
};
|
|
3578
3726
|
export type GqlEstimateGasPriceQueryVariables = Exact<{
|
|
3579
|
-
blockHorizon: Scalars['U32'];
|
|
3727
|
+
blockHorizon: Scalars['U32']['input'];
|
|
3580
3728
|
}>;
|
|
3581
3729
|
export type GqlEstimateGasPriceQuery = {
|
|
3582
3730
|
estimateGasPrice: {
|
|
@@ -3585,10 +3733,10 @@ export type GqlEstimateGasPriceQuery = {
|
|
|
3585
3733
|
};
|
|
3586
3734
|
export type GqlGetBalancesQueryVariables = Exact<{
|
|
3587
3735
|
filter: GqlBalanceFilterInput;
|
|
3588
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3589
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3590
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3591
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3736
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3737
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3738
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3739
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3592
3740
|
}>;
|
|
3593
3741
|
export type GqlGetBalancesQuery = {
|
|
3594
3742
|
balances: {
|
|
@@ -3602,11 +3750,11 @@ export type GqlGetBalancesQuery = {
|
|
|
3602
3750
|
};
|
|
3603
3751
|
};
|
|
3604
3752
|
export type GqlGetMessagesQueryVariables = Exact<{
|
|
3605
|
-
owner: Scalars['Address'];
|
|
3606
|
-
after?: InputMaybe<Scalars['String']>;
|
|
3607
|
-
before?: InputMaybe<Scalars['String']>;
|
|
3608
|
-
first?: InputMaybe<Scalars['Int']>;
|
|
3609
|
-
last?: InputMaybe<Scalars['Int']>;
|
|
3753
|
+
owner: Scalars['Address']['input'];
|
|
3754
|
+
after?: InputMaybe<Scalars['String']['input']>;
|
|
3755
|
+
before?: InputMaybe<Scalars['String']['input']>;
|
|
3756
|
+
first?: InputMaybe<Scalars['Int']['input']>;
|
|
3757
|
+
last?: InputMaybe<Scalars['Int']['input']>;
|
|
3610
3758
|
}>;
|
|
3611
3759
|
export type GqlGetMessagesQuery = {
|
|
3612
3760
|
messages: {
|
|
@@ -3623,10 +3771,10 @@ export type GqlGetMessagesQuery = {
|
|
|
3623
3771
|
};
|
|
3624
3772
|
};
|
|
3625
3773
|
export type GqlGetMessageProofQueryVariables = Exact<{
|
|
3626
|
-
transactionId: Scalars['TransactionId'];
|
|
3627
|
-
nonce: Scalars['Nonce'];
|
|
3628
|
-
commitBlockId?: InputMaybe<Scalars['BlockId']>;
|
|
3629
|
-
commitBlockHeight?: InputMaybe<Scalars['U32']>;
|
|
3774
|
+
transactionId: Scalars['TransactionId']['input'];
|
|
3775
|
+
nonce: Scalars['Nonce']['input'];
|
|
3776
|
+
commitBlockId?: InputMaybe<Scalars['BlockId']['input']>;
|
|
3777
|
+
commitBlockHeight?: InputMaybe<Scalars['U32']['input']>;
|
|
3630
3778
|
}>;
|
|
3631
3779
|
export type GqlGetMessageProofQuery = {
|
|
3632
3780
|
messageProof?: {
|
|
@@ -3678,7 +3826,7 @@ export type GqlGetMessageProofQuery = {
|
|
|
3678
3826
|
} | null;
|
|
3679
3827
|
};
|
|
3680
3828
|
export type GqlGetMessageStatusQueryVariables = Exact<{
|
|
3681
|
-
nonce: Scalars['Nonce'];
|
|
3829
|
+
nonce: Scalars['Nonce']['input'];
|
|
3682
3830
|
}>;
|
|
3683
3831
|
export type GqlGetMessageStatusQuery = {
|
|
3684
3832
|
messageStatus: {
|
|
@@ -3686,7 +3834,7 @@ export type GqlGetMessageStatusQuery = {
|
|
|
3686
3834
|
};
|
|
3687
3835
|
};
|
|
3688
3836
|
export type GqlGetRelayedTransactionStatusQueryVariables = Exact<{
|
|
3689
|
-
relayedTransactionId: Scalars['RelayedTransactionId'];
|
|
3837
|
+
relayedTransactionId: Scalars['RelayedTransactionId']['input'];
|
|
3690
3838
|
}>;
|
|
3691
3839
|
export type GqlGetRelayedTransactionStatusQuery = {
|
|
3692
3840
|
relayedTransactionStatus?: {
|
|
@@ -3695,9 +3843,9 @@ export type GqlGetRelayedTransactionStatusQuery = {
|
|
|
3695
3843
|
} | null;
|
|
3696
3844
|
};
|
|
3697
3845
|
export type GqlDryRunMutationVariables = Exact<{
|
|
3698
|
-
encodedTransactions: Array<Scalars['HexString']> | Scalars['HexString'];
|
|
3699
|
-
utxoValidation?: InputMaybe<Scalars['Boolean']>;
|
|
3700
|
-
gasPrice?: InputMaybe<Scalars['U64']>;
|
|
3846
|
+
encodedTransactions: Array<Scalars['HexString']['input']> | Scalars['HexString']['input'];
|
|
3847
|
+
utxoValidation?: InputMaybe<Scalars['Boolean']['input']>;
|
|
3848
|
+
gasPrice?: InputMaybe<Scalars['U64']['input']>;
|
|
3701
3849
|
}>;
|
|
3702
3850
|
export type GqlDryRunMutation = {
|
|
3703
3851
|
dryRun: Array<{
|
|
@@ -3753,7 +3901,7 @@ export type GqlDryRunMutation = {
|
|
|
3753
3901
|
}>;
|
|
3754
3902
|
};
|
|
3755
3903
|
export type GqlSubmitMutationVariables = Exact<{
|
|
3756
|
-
encodedTransaction: Scalars['HexString'];
|
|
3904
|
+
encodedTransaction: Scalars['HexString']['input'];
|
|
3757
3905
|
}>;
|
|
3758
3906
|
export type GqlSubmitMutation = {
|
|
3759
3907
|
submit: {
|
|
@@ -3761,14 +3909,14 @@ export type GqlSubmitMutation = {
|
|
|
3761
3909
|
};
|
|
3762
3910
|
};
|
|
3763
3911
|
export type GqlProduceBlocksMutationVariables = Exact<{
|
|
3764
|
-
startTimestamp?: InputMaybe<Scalars['Tai64Timestamp']>;
|
|
3765
|
-
blocksToProduce: Scalars['U32'];
|
|
3912
|
+
startTimestamp?: InputMaybe<Scalars['Tai64Timestamp']['input']>;
|
|
3913
|
+
blocksToProduce: Scalars['U32']['input'];
|
|
3766
3914
|
}>;
|
|
3767
3915
|
export type GqlProduceBlocksMutation = {
|
|
3768
3916
|
produceBlocks: string;
|
|
3769
3917
|
};
|
|
3770
3918
|
export type GqlGetMessageByNonceQueryVariables = Exact<{
|
|
3771
|
-
nonce: Scalars['Nonce'];
|
|
3919
|
+
nonce: Scalars['Nonce']['input'];
|
|
3772
3920
|
}>;
|
|
3773
3921
|
export type GqlGetMessageByNonceQuery = {
|
|
3774
3922
|
message?: {
|
|
@@ -3781,7 +3929,7 @@ export type GqlGetMessageByNonceQuery = {
|
|
|
3781
3929
|
} | null;
|
|
3782
3930
|
};
|
|
3783
3931
|
export type GqlSubmitAndAwaitSubscriptionVariables = Exact<{
|
|
3784
|
-
encodedTransaction: Scalars['HexString'];
|
|
3932
|
+
encodedTransaction: Scalars['HexString']['input'];
|
|
3785
3933
|
}>;
|
|
3786
3934
|
export type GqlSubmitAndAwaitSubscription = {
|
|
3787
3935
|
submitAndAwait: {
|
|
@@ -3796,7 +3944,7 @@ export type GqlSubmitAndAwaitSubscription = {
|
|
|
3796
3944
|
};
|
|
3797
3945
|
};
|
|
3798
3946
|
export type GqlStatusChangeSubscriptionVariables = Exact<{
|
|
3799
|
-
transactionId: Scalars['TransactionId'];
|
|
3947
|
+
transactionId: Scalars['TransactionId']['input'];
|
|
3800
3948
|
}>;
|
|
3801
3949
|
export type GqlStatusChangeSubscription = {
|
|
3802
3950
|
statusChange: {
|
|
@@ -3873,8 +4021,8 @@ export declare const ProduceBlocksDocument: DocumentNode;
|
|
|
3873
4021
|
export declare const GetMessageByNonceDocument: DocumentNode;
|
|
3874
4022
|
export declare const SubmitAndAwaitDocument: DocumentNode;
|
|
3875
4023
|
export declare const StatusChangeDocument: DocumentNode;
|
|
3876
|
-
export type Requester<C = {}
|
|
3877
|
-
export declare function getSdk<C
|
|
4024
|
+
export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
|
|
4025
|
+
export declare function getSdk<C>(requester: Requester<C>): {
|
|
3878
4026
|
getVersion(variables?: GqlGetVersionQueryVariables, options?: C): Promise<GqlGetVersionQuery>;
|
|
3879
4027
|
getNodeInfo(variables?: GqlGetNodeInfoQueryVariables, options?: C): Promise<GqlGetNodeInfoQuery>;
|
|
3880
4028
|
getChain(variables?: GqlGetChainQueryVariables, options?: C): Promise<GqlGetChainQuery>;
|