@ocap/client 1.30.16 → 1.30.18

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.
package/docs/README.md CHANGED
@@ -1,8 +1,14 @@
1
1
  ## GraphQLClient
2
2
 
3
- An http client that can read/write data to a forge powered blockchain node, can be used in both node.js and browser.
3
+ An http client that reads/writes OCAP blockchain data. CBOR-only wire
4
+ encoding — browser / Worker / Node bundles stay off the protobuf runtime.
4
5
 
5
- Please note that, due to internal implementation of google-protobuf, all `repeated fields` names are suffixed with `List`
6
+ For back-compat with chain nodes that still decode legacy protobuf
7
+ transactions, or to test the dual-encoding path end-to-end, import the
8
+ `@ocap/client/legacy` subpath which ships both encoders.
9
+
10
+ Internal protobuf repeated-field naming (`xxxList`) is preserved in
11
+ response objects the chain returns — this is a server-side convention.
6
12
 
7
13
  **Kind**: global class\
8
14
  **See**
@@ -16,7 +22,7 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
16
22
  <!---->
17
23
 
18
24
  * [GraphQLClient](#GraphQLClient)
19
- * [new GraphQLClient(endpoint, autoInit)](#new_GraphQLClient_new)
25
+ * [new GraphQLClient(endpoint, autoInit, \[options\])](#new_GraphQLClient_new)
20
26
  * *instance*
21
27
  * [fromUnitToToken(value)](#GraphQLClient+fromUnitToToken) ⇒ `string`
22
28
  * [fromTokenToUnit(amount)](#GraphQLClient+fromTokenToUnit) ⇒ `BN`
@@ -43,81 +49,81 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
43
49
  * [doRawQuery(query)](#GraphQLClient+doRawQuery) ⇒ `Promise`
44
50
  * [doRawSubscription(query)](#GraphQLClient+doRawSubscription) ⇒ `Promise`
45
51
  * [sendAccountMigrateTx(params, extra)](#GraphQLClient+sendAccountMigrateTx) ⇒ `Promise.<string>`
52
+ * [sendDelegateTx(params, extra)](#GraphQLClient+sendDelegateTx) ⇒ `Promise.<string>`
53
+ * [sendRevokeDelegateTx(params, extra)](#GraphQLClient+sendRevokeDelegateTx) ⇒ `Promise.<string>`
54
+ * [sendUpgradeNodeTx(params, extra)](#GraphQLClient+sendUpgradeNodeTx) ⇒ `Promise.<string>`
55
+ * [sendExchangeTx(params, extra)](#GraphQLClient+sendExchangeTx) ⇒ `Promise.<string>`
56
+ * [sendExchangeV2Tx(params, extra)](#GraphQLClient+sendExchangeV2Tx) ⇒ `Promise.<string>`
57
+ * [sendTransferTx(params, extra)](#GraphQLClient+sendTransferTx) ⇒ `Promise.<string>`
58
+ * [sendTransferV2Tx(params, extra)](#GraphQLClient+sendTransferV2Tx) ⇒ `Promise.<string>`
59
+ * [sendTransferV3Tx(params, extra)](#GraphQLClient+sendTransferV3Tx) ⇒ `Promise.<string>`
60
+ * [sendCreateTokenTx(params, extra)](#GraphQLClient+sendCreateTokenTx) ⇒ `Promise.<string>`
46
61
  * [sendAcquireAssetV2Tx(params, extra)](#GraphQLClient+sendAcquireAssetV2Tx) ⇒ `Promise.<string>`
47
62
  * [sendAcquireAssetV3Tx(params, extra)](#GraphQLClient+sendAcquireAssetV3Tx) ⇒ `Promise.<string>`
48
- * [sendBurnTokenTx(params, extra)](#GraphQLClient+sendBurnTokenTx) ⇒ `Promise.<string>`
49
- * [sendClaimBlockRewardTx(params, extra)](#GraphQLClient+sendClaimBlockRewardTx) ⇒ `Promise.<string>`
50
- * [sendClaimStakeTx(params, extra)](#GraphQLClient+sendClaimStakeTx) ⇒ `Promise.<string>`
51
- * [sendCloseRollupTx(params, extra)](#GraphQLClient+sendCloseRollupTx) ⇒ `Promise.<string>`
52
- * [sendConsumeAssetTx(params, extra)](#GraphQLClient+sendConsumeAssetTx) ⇒ `Promise.<string>`
63
+ * [sendMintAssetTx(params, extra)](#GraphQLClient+sendMintAssetTx) ⇒ `Promise.<string>`
53
64
  * [sendCreateAssetTx(params, extra)](#GraphQLClient+sendCreateAssetTx) ⇒ `Promise.<string>`
65
+ * [sendUpdateAssetTx(params, extra)](#GraphQLClient+sendUpdateAssetTx) ⇒ `Promise.<string>`
66
+ * [sendConsumeAssetTx(params, extra)](#GraphQLClient+sendConsumeAssetTx) ⇒ `Promise.<string>`
54
67
  * [sendCreateFactoryTx(params, extra)](#GraphQLClient+sendCreateFactoryTx) ⇒ `Promise.<string>`
55
- * [sendCreateRollupBlockTx(params, extra)](#GraphQLClient+sendCreateRollupBlockTx) ⇒ `Promise.<string>`
68
+ * [sendStakeTx(params, extra)](#GraphQLClient+sendStakeTx) ⇒ `Promise.<string>`
69
+ * [sendRevokeStakeTx(params, extra)](#GraphQLClient+sendRevokeStakeTx) ⇒ `Promise.<string>`
70
+ * [sendClaimStakeTx(params, extra)](#GraphQLClient+sendClaimStakeTx) ⇒ `Promise.<string>`
71
+ * [sendSlashStakeTx(params, extra)](#GraphQLClient+sendSlashStakeTx) ⇒ `Promise.<string>`
72
+ * [sendReturnStakeTx(params, extra)](#GraphQLClient+sendReturnStakeTx) ⇒ `Promise.<string>`
56
73
  * [sendCreateRollupTx(params, extra)](#GraphQLClient+sendCreateRollupTx) ⇒ `Promise.<string>`
57
- * [sendCreateTokenFactoryTx(params, extra)](#GraphQLClient+sendCreateTokenFactoryTx) ⇒ `Promise.<string>`
58
- * [sendCreateTokenTx(params, extra)](#GraphQLClient+sendCreateTokenTx) ⇒ `Promise.<string>`
59
- * [sendDelegateTx(params, extra)](#GraphQLClient+sendDelegateTx) ⇒ `Promise.<string>`
60
- * [sendDepositTokenV2Tx(params, extra)](#GraphQLClient+sendDepositTokenV2Tx) ⇒ `Promise.<string>`
61
- * [sendExchangeTx(params, extra)](#GraphQLClient+sendExchangeTx) ⇒ `Promise.<string>`
62
- * [sendExchangeV2Tx(params, extra)](#GraphQLClient+sendExchangeV2Tx) ⇒ `Promise.<string>`
74
+ * [sendUpdateRollupTx(params, extra)](#GraphQLClient+sendUpdateRollupTx) ⇒ `Promise.<string>`
63
75
  * [sendJoinRollupTx(params, extra)](#GraphQLClient+sendJoinRollupTx) ⇒ `Promise.<string>`
64
76
  * [sendLeaveRollupTx(params, extra)](#GraphQLClient+sendLeaveRollupTx) ⇒ `Promise.<string>`
65
- * [sendMigrateRollupTx(params, extra)](#GraphQLClient+sendMigrateRollupTx) ⇒ `Promise.<string>`
66
- * [sendMintAssetTx(params, extra)](#GraphQLClient+sendMintAssetTx) ⇒ `Promise.<string>`
67
- * [sendMintTokenTx(params, extra)](#GraphQLClient+sendMintTokenTx) ⇒ `Promise.<string>`
77
+ * [sendCreateRollupBlockTx(params, extra)](#GraphQLClient+sendCreateRollupBlockTx) ⇒ `Promise.<string>`
78
+ * [sendClaimBlockRewardTx(params, extra)](#GraphQLClient+sendClaimBlockRewardTx) ⇒ `Promise.<string>`
68
79
  * [sendPauseRollupTx(params, extra)](#GraphQLClient+sendPauseRollupTx) ⇒ `Promise.<string>`
69
80
  * [sendResumeRollupTx(params, extra)](#GraphQLClient+sendResumeRollupTx) ⇒ `Promise.<string>`
70
- * [sendReturnStakeTx(params, extra)](#GraphQLClient+sendReturnStakeTx) ⇒ `Promise.<string>`
71
- * [sendRevokeDelegateTx(params, extra)](#GraphQLClient+sendRevokeDelegateTx) ⇒ `Promise.<string>`
72
- * [sendRevokeStakeTx(params, extra)](#GraphQLClient+sendRevokeStakeTx) ⇒ `Promise.<string>`
73
- * [sendSlashStakeTx(params, extra)](#GraphQLClient+sendSlashStakeTx) ⇒ `Promise.<string>`
74
- * [sendStakeTx(params, extra)](#GraphQLClient+sendStakeTx) ⇒ `Promise.<string>`
75
- * [sendTransferTx(params, extra)](#GraphQLClient+sendTransferTx) ⇒ `Promise.<string>`
76
- * [sendTransferV2Tx(params, extra)](#GraphQLClient+sendTransferV2Tx) ⇒ `Promise.<string>`
77
- * [sendTransferV3Tx(params, extra)](#GraphQLClient+sendTransferV3Tx) ⇒ `Promise.<string>`
78
- * [sendUpdateAssetTx(params, extra)](#GraphQLClient+sendUpdateAssetTx) ⇒ `Promise.<string>`
79
- * [sendUpdateRollupTx(params, extra)](#GraphQLClient+sendUpdateRollupTx) ⇒ `Promise.<string>`
80
- * [sendUpdateTokenFactoryTx(params, extra)](#GraphQLClient+sendUpdateTokenFactoryTx) ⇒ `Promise.<string>`
81
- * [sendUpgradeNodeTx(params, extra)](#GraphQLClient+sendUpgradeNodeTx) ⇒ `Promise.<string>`
81
+ * [sendCloseRollupTx(params, extra)](#GraphQLClient+sendCloseRollupTx) ⇒ `Promise.<string>`
82
+ * [sendMigrateRollupTx(params, extra)](#GraphQLClient+sendMigrateRollupTx) ⇒ `Promise.<string>`
83
+ * [sendDepositTokenV2Tx(params, extra)](#GraphQLClient+sendDepositTokenV2Tx) ⇒ `Promise.<string>`
82
84
  * [sendWithdrawTokenV2Tx(params, extra)](#GraphQLClient+sendWithdrawTokenV2Tx) ⇒ `Promise.<string>`
85
+ * [sendCreateTokenFactoryTx(params, extra)](#GraphQLClient+sendCreateTokenFactoryTx) ⇒ `Promise.<string>`
86
+ * [sendUpdateTokenFactoryTx(params, extra)](#GraphQLClient+sendUpdateTokenFactoryTx) ⇒ `Promise.<string>`
87
+ * [sendMintTokenTx(params, extra)](#GraphQLClient+sendMintTokenTx) ⇒ `Promise.<string>`
88
+ * [sendBurnTokenTx(params, extra)](#GraphQLClient+sendBurnTokenTx) ⇒ `Promise.<string>`
83
89
  * [encodeAccountMigrateTx(params)](#GraphQLClient+encodeAccountMigrateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
90
+ * [encodeDelegateTx(params)](#GraphQLClient+encodeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
91
+ * [encodeRevokeDelegateTx(params)](#GraphQLClient+encodeRevokeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
92
+ * [encodeUpgradeNodeTx(params)](#GraphQLClient+encodeUpgradeNodeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
93
+ * [encodeExchangeTx(params)](#GraphQLClient+encodeExchangeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
94
+ * [encodeExchangeV2Tx(params)](#GraphQLClient+encodeExchangeV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
95
+ * [encodeTransferTx(params)](#GraphQLClient+encodeTransferTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
96
+ * [encodeTransferV2Tx(params)](#GraphQLClient+encodeTransferV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
97
+ * [encodeTransferV3Tx(params)](#GraphQLClient+encodeTransferV3Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
98
+ * [encodeCreateTokenTx(params)](#GraphQLClient+encodeCreateTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
84
99
  * [encodeAcquireAssetV2Tx(params)](#GraphQLClient+encodeAcquireAssetV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
85
100
  * [encodeAcquireAssetV3Tx(params)](#GraphQLClient+encodeAcquireAssetV3Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
86
- * [encodeBurnTokenTx(params)](#GraphQLClient+encodeBurnTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
87
- * [encodeClaimBlockRewardTx(params)](#GraphQLClient+encodeClaimBlockRewardTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
88
- * [encodeClaimStakeTx(params)](#GraphQLClient+encodeClaimStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
89
- * [encodeCloseRollupTx(params)](#GraphQLClient+encodeCloseRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
90
- * [encodeConsumeAssetTx(params)](#GraphQLClient+encodeConsumeAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
101
+ * [encodeMintAssetTx(params)](#GraphQLClient+encodeMintAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
91
102
  * [encodeCreateAssetTx(params)](#GraphQLClient+encodeCreateAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
103
+ * [encodeUpdateAssetTx(params)](#GraphQLClient+encodeUpdateAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
104
+ * [encodeConsumeAssetTx(params)](#GraphQLClient+encodeConsumeAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
92
105
  * [encodeCreateFactoryTx(params)](#GraphQLClient+encodeCreateFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
93
- * [encodeCreateRollupBlockTx(params)](#GraphQLClient+encodeCreateRollupBlockTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
106
+ * [encodeStakeTx(params)](#GraphQLClient+encodeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
107
+ * [encodeRevokeStakeTx(params)](#GraphQLClient+encodeRevokeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
108
+ * [encodeClaimStakeTx(params)](#GraphQLClient+encodeClaimStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
109
+ * [encodeSlashStakeTx(params)](#GraphQLClient+encodeSlashStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
110
+ * [encodeReturnStakeTx(params)](#GraphQLClient+encodeReturnStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
94
111
  * [encodeCreateRollupTx(params)](#GraphQLClient+encodeCreateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
95
- * [encodeCreateTokenFactoryTx(params)](#GraphQLClient+encodeCreateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
96
- * [encodeCreateTokenTx(params)](#GraphQLClient+encodeCreateTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
97
- * [encodeDelegateTx(params)](#GraphQLClient+encodeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
98
- * [encodeDepositTokenV2Tx(params)](#GraphQLClient+encodeDepositTokenV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
99
- * [encodeExchangeTx(params)](#GraphQLClient+encodeExchangeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
100
- * [encodeExchangeV2Tx(params)](#GraphQLClient+encodeExchangeV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
112
+ * [encodeUpdateRollupTx(params)](#GraphQLClient+encodeUpdateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
101
113
  * [encodeJoinRollupTx(params)](#GraphQLClient+encodeJoinRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
102
114
  * [encodeLeaveRollupTx(params)](#GraphQLClient+encodeLeaveRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
103
- * [encodeMigrateRollupTx(params)](#GraphQLClient+encodeMigrateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
104
- * [encodeMintAssetTx(params)](#GraphQLClient+encodeMintAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
105
- * [encodeMintTokenTx(params)](#GraphQLClient+encodeMintTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
115
+ * [encodeCreateRollupBlockTx(params)](#GraphQLClient+encodeCreateRollupBlockTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
116
+ * [encodeClaimBlockRewardTx(params)](#GraphQLClient+encodeClaimBlockRewardTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
106
117
  * [encodePauseRollupTx(params)](#GraphQLClient+encodePauseRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
107
118
  * [encodeResumeRollupTx(params)](#GraphQLClient+encodeResumeRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
108
- * [encodeReturnStakeTx(params)](#GraphQLClient+encodeReturnStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
109
- * [encodeRevokeDelegateTx(params)](#GraphQLClient+encodeRevokeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
110
- * [encodeRevokeStakeTx(params)](#GraphQLClient+encodeRevokeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
111
- * [encodeSlashStakeTx(params)](#GraphQLClient+encodeSlashStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
112
- * [encodeStakeTx(params)](#GraphQLClient+encodeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
113
- * [encodeTransferTx(params)](#GraphQLClient+encodeTransferTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
114
- * [encodeTransferV2Tx(params)](#GraphQLClient+encodeTransferV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
115
- * [encodeTransferV3Tx(params)](#GraphQLClient+encodeTransferV3Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
116
- * [encodeUpdateAssetTx(params)](#GraphQLClient+encodeUpdateAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
117
- * [encodeUpdateRollupTx(params)](#GraphQLClient+encodeUpdateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
118
- * [encodeUpdateTokenFactoryTx(params)](#GraphQLClient+encodeUpdateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
119
- * [encodeUpgradeNodeTx(params)](#GraphQLClient+encodeUpgradeNodeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
119
+ * [encodeCloseRollupTx(params)](#GraphQLClient+encodeCloseRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
120
+ * [encodeMigrateRollupTx(params)](#GraphQLClient+encodeMigrateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
121
+ * [encodeDepositTokenV2Tx(params)](#GraphQLClient+encodeDepositTokenV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
120
122
  * [encodeWithdrawTokenV2Tx(params)](#GraphQLClient+encodeWithdrawTokenV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
123
+ * [encodeCreateTokenFactoryTx(params)](#GraphQLClient+encodeCreateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
124
+ * [encodeUpdateTokenFactoryTx(params)](#GraphQLClient+encodeUpdateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
125
+ * [encodeMintTokenTx(params)](#GraphQLClient+encodeMintTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
126
+ * [encodeBurnTokenTx(params)](#GraphQLClient+encodeBurnTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
121
127
  * [getAccountState(params)](#GraphQLClient+getAccountState) ⇒ [`Promise.<ResponseGetAccountState>`](#GraphQLClient.ResponseGetAccountState)
122
128
  * [getAssetState(params)](#GraphQLClient+getAssetState) ⇒ [`Promise.<ResponseGetAssetState>`](#GraphQLClient.ResponseGetAssetState)
123
129
  * [getFactoryState(params)](#GraphQLClient+getFactoryState) ⇒ [`Promise.<ResponseGetFactoryState>`](#GraphQLClient.ResponseGetFactoryState)
@@ -191,6 +197,7 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
191
197
  * [RequestListRollupValidatorsInput](#GraphQLClient.RequestListRollupValidatorsInput) : `object`
192
198
  * [RequestListRollupsInput](#GraphQLClient.RequestListRollupsInput) : `object`
193
199
  * [RequestListStakesInput](#GraphQLClient.RequestListStakesInput) : `object`
200
+ * [RequestListTokenFactoriesInput](#GraphQLClient.RequestListTokenFactoriesInput) : `object`
194
201
  * [RequestListTokenFlowsInput](#GraphQLClient.RequestListTokenFlowsInput) : `object`
195
202
  * [RequestListTokensInput](#GraphQLClient.RequestListTokensInput) : `object`
196
203
  * [RequestListTopAccountsInput](#GraphQLClient.RequestListTopAccountsInput) : `object`
@@ -224,8 +231,8 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
224
231
  * [BlockID](#GraphQLClient.BlockID) : `object`
225
232
  * [BlockInfo](#GraphQLClient.BlockInfo) : `object`
226
233
  * [BlockInfoSimple](#GraphQLClient.BlockInfoSimple) : `object`
234
+ * [BurnTokenTx](#GraphQLClient.BurnTokenTx) : `object`
227
235
  * [ChainInfo](#GraphQLClient.ChainInfo) : `object`
228
- * [ChainInfo\_ForgeAppsVersionEntry](#GraphQLClient.ChainInfo_ForgeAppsVersionEntry) : `object`
229
236
  * [ClaimBlockRewardTx](#GraphQLClient.ClaimBlockRewardTx) : `object`
230
237
  * [ClaimStakeTx](#GraphQLClient.ClaimStakeTx) : `object`
231
238
  * [CloseRollupTx](#GraphQLClient.CloseRollupTx) : `object`
@@ -235,14 +242,15 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
235
242
  * [CreateFactoryTx](#GraphQLClient.CreateFactoryTx) : `object`
236
243
  * [CreateRollupBlockTx](#GraphQLClient.CreateRollupBlockTx) : `object`
237
244
  * [CreateRollupTx](#GraphQLClient.CreateRollupTx) : `object`
245
+ * [CreateTokenFactoryTx](#GraphQLClient.CreateTokenFactoryTx) : `object`
238
246
  * [CreateTokenTx](#GraphQLClient.CreateTokenTx) : `object`
239
247
  * [CurveConfig](#GraphQLClient.CurveConfig) : `object`
248
+ * [DeclareTx](#GraphQLClient.DeclareTx) : `object`
240
249
  * [DelegateConfig](#GraphQLClient.DelegateConfig) : `object`
241
250
  * [DelegateLimit](#GraphQLClient.DelegateLimit) : `object`
242
251
  * [DelegateOp](#GraphQLClient.DelegateOp) : `object`
243
252
  * [DelegateOpState](#GraphQLClient.DelegateOpState) : `object`
244
253
  * [DelegateState](#GraphQLClient.DelegateState) : `object`
245
- * [DelegateState\_OpsEntry](#GraphQLClient.DelegateState_OpsEntry) : `object`
246
254
  * [DelegateTx](#GraphQLClient.DelegateTx) : `object`
247
255
  * [DepositTokenV2Tx](#GraphQLClient.DepositTokenV2Tx) : `object`
248
256
  * [Evidence](#GraphQLClient.Evidence) : `object`
@@ -253,7 +261,6 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
253
261
  * [ExchangeV2Tx](#GraphQLClient.ExchangeV2Tx) : `object`
254
262
  * [ForeignToken](#GraphQLClient.ForeignToken) : `object`
255
263
  * [ForgeState](#GraphQLClient.ForgeState) : `object`
256
- * [ForgeState\_TasksEntry](#GraphQLClient.ForgeState_TasksEntry) : `object`
257
264
  * [ForgeStats](#GraphQLClient.ForgeStats) : `object`
258
265
  * [ForgeToken](#GraphQLClient.ForgeToken) : `object`
259
266
  * [GasEstimate](#GraphQLClient.GasEstimate) : `object`
@@ -262,7 +269,6 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
262
269
  * [IndexedAssetState](#GraphQLClient.IndexedAssetState) : `object`
263
270
  * [IndexedBlock](#GraphQLClient.IndexedBlock) : `object`
264
271
  * [IndexedDelegationState](#GraphQLClient.IndexedDelegationState) : `object`
265
- * [IndexedDelegationState\_OpsEntry](#GraphQLClient.IndexedDelegationState_OpsEntry) : `object`
266
272
  * [IndexedFactoryInput](#GraphQLClient.IndexedFactoryInput) : `object`
267
273
  * [IndexedFactoryState](#GraphQLClient.IndexedFactoryState) : `object`
268
274
  * [IndexedRollupBlock](#GraphQLClient.IndexedRollupBlock) : `object`
@@ -279,13 +285,13 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
279
285
  * [LeaveRollupTx](#GraphQLClient.LeaveRollupTx) : `object`
280
286
  * [MigrateRollupTx](#GraphQLClient.MigrateRollupTx) : `object`
281
287
  * [MintAssetTx](#GraphQLClient.MintAssetTx) : `object`
288
+ * [MintTokenTx](#GraphQLClient.MintTokenTx) : `object`
282
289
  * [Multisig](#GraphQLClient.Multisig) : `object`
283
290
  * [NFTDisplay](#GraphQLClient.NFTDisplay) : `object`
284
291
  * [NFTEndpoint](#GraphQLClient.NFTEndpoint) : `object`
285
292
  * [NFTIssuer](#GraphQLClient.NFTIssuer) : `object`
286
293
  * [NetInfo](#GraphQLClient.NetInfo) : `object`
287
294
  * [NodeInfo](#GraphQLClient.NodeInfo) : `object`
288
- * [NodeInfo\_ForgeAppsVersionEntry](#GraphQLClient.NodeInfo_ForgeAppsVersionEntry) : `object`
289
295
  * [PageInfo](#GraphQLClient.PageInfo) : `object`
290
296
  * [PartSetHeader](#GraphQLClient.PartSetHeader) : `object`
291
297
  * [PauseRollupTx](#GraphQLClient.PauseRollupTx) : `object`
@@ -351,6 +357,7 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
351
357
  * [TokenInfo](#GraphQLClient.TokenInfo) : `object`
352
358
  * [TokenInput](#GraphQLClient.TokenInput) : `object`
353
359
  * [TokenLimit](#GraphQLClient.TokenLimit) : `object`
360
+ * [TokenMeta](#GraphQLClient.TokenMeta) : `object`
354
361
  * [TokenState](#GraphQLClient.TokenState) : `object`
355
362
  * [TokenSymbol](#GraphQLClient.TokenSymbol) : `object`
356
363
  * [Transaction](#GraphQLClient.Transaction) : `object`
@@ -367,6 +374,7 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
367
374
  * [UnconfirmedTxs](#GraphQLClient.UnconfirmedTxs) : `object`
368
375
  * [UpdateAssetTx](#GraphQLClient.UpdateAssetTx) : `object`
369
376
  * [UpdateRollupTx](#GraphQLClient.UpdateRollupTx) : `object`
377
+ * [UpdateTokenFactoryTx](#GraphQLClient.UpdateTokenFactoryTx) : `object`
370
378
  * [UpgradeInfo](#GraphQLClient.UpgradeInfo) : `object`
371
379
  * [UpgradeNodeTx](#GraphQLClient.UpgradeNodeTx) : `object`
372
380
  * [UpgradeTask](#GraphQLClient.UpgradeTask) : `object`
@@ -418,52 +426,53 @@ Please note that, due to internal implementation of google-protobuf, all `repeat
418
426
  * [ListTokenFactoriesParams](#GraphQLClient.ListTokenFactoriesParams) : `object`
419
427
  * [SendTxParams](#GraphQLClient.SendTxParams) : `object`
420
428
  * [AccountMigrateTxInput](#GraphQLClient.AccountMigrateTxInput) : `Object`
429
+ * [DelegateTxInput](#GraphQLClient.DelegateTxInput) : `Object`
430
+ * [RevokeDelegateTxInput](#GraphQLClient.RevokeDelegateTxInput) : `Object`
431
+ * [UpgradeNodeTxInput](#GraphQLClient.UpgradeNodeTxInput) : `Object`
432
+ * [ExchangeTxInput](#GraphQLClient.ExchangeTxInput) : `Object`
433
+ * [ExchangeV2TxInput](#GraphQLClient.ExchangeV2TxInput) : `Object`
434
+ * [TransferTxInput](#GraphQLClient.TransferTxInput) : `Object`
435
+ * [TransferV2TxInput](#GraphQLClient.TransferV2TxInput) : `Object`
436
+ * [TransferV3TxInput](#GraphQLClient.TransferV3TxInput) : `Object`
437
+ * [CreateTokenTxInput](#GraphQLClient.CreateTokenTxInput) : `Object`
421
438
  * [AcquireAssetV2TxInput](#GraphQLClient.AcquireAssetV2TxInput) : `Object`
422
439
  * [AcquireAssetV3TxInput](#GraphQLClient.AcquireAssetV3TxInput) : `Object`
423
- * [BurnTokenTxInput](#GraphQLClient.BurnTokenTxInput) : `Object`
424
- * [ClaimBlockRewardTxInput](#GraphQLClient.ClaimBlockRewardTxInput) : `Object`
425
- * [ClaimStakeTxInput](#GraphQLClient.ClaimStakeTxInput) : `Object`
426
- * [CloseRollupTxInput](#GraphQLClient.CloseRollupTxInput) : `Object`
427
- * [ConsumeAssetTxInput](#GraphQLClient.ConsumeAssetTxInput) : `Object`
440
+ * [MintAssetTxInput](#GraphQLClient.MintAssetTxInput) : `Object`
428
441
  * [CreateAssetTxInput](#GraphQLClient.CreateAssetTxInput) : `Object`
442
+ * [UpdateAssetTxInput](#GraphQLClient.UpdateAssetTxInput) : `Object`
443
+ * [ConsumeAssetTxInput](#GraphQLClient.ConsumeAssetTxInput) : `Object`
429
444
  * [CreateFactoryTxInput](#GraphQLClient.CreateFactoryTxInput) : `Object`
430
- * [CreateRollupBlockTxInput](#GraphQLClient.CreateRollupBlockTxInput) : `Object`
445
+ * [StakeTxInput](#GraphQLClient.StakeTxInput) : `Object`
446
+ * [RevokeStakeTxInput](#GraphQLClient.RevokeStakeTxInput) : `Object`
447
+ * [ClaimStakeTxInput](#GraphQLClient.ClaimStakeTxInput) : `Object`
448
+ * [SlashStakeTxInput](#GraphQLClient.SlashStakeTxInput) : `Object`
449
+ * [ReturnStakeTxInput](#GraphQLClient.ReturnStakeTxInput) : `Object`
431
450
  * [CreateRollupTxInput](#GraphQLClient.CreateRollupTxInput) : `Object`
432
- * [CreateTokenFactoryTxInput](#GraphQLClient.CreateTokenFactoryTxInput) : `Object`
433
- * [CreateTokenTxInput](#GraphQLClient.CreateTokenTxInput) : `Object`
434
- * [DelegateTxInput](#GraphQLClient.DelegateTxInput) : `Object`
435
- * [DepositTokenV2TxInput](#GraphQLClient.DepositTokenV2TxInput) : `Object`
436
- * [ExchangeTxInput](#GraphQLClient.ExchangeTxInput) : `Object`
437
- * [ExchangeV2TxInput](#GraphQLClient.ExchangeV2TxInput) : `Object`
451
+ * [UpdateRollupTxInput](#GraphQLClient.UpdateRollupTxInput) : `Object`
438
452
  * [JoinRollupTxInput](#GraphQLClient.JoinRollupTxInput) : `Object`
439
453
  * [LeaveRollupTxInput](#GraphQLClient.LeaveRollupTxInput) : `Object`
440
- * [MigrateRollupTxInput](#GraphQLClient.MigrateRollupTxInput) : `Object`
441
- * [MintAssetTxInput](#GraphQLClient.MintAssetTxInput) : `Object`
442
- * [MintTokenTxInput](#GraphQLClient.MintTokenTxInput) : `Object`
454
+ * [CreateRollupBlockTxInput](#GraphQLClient.CreateRollupBlockTxInput) : `Object`
455
+ * [ClaimBlockRewardTxInput](#GraphQLClient.ClaimBlockRewardTxInput) : `Object`
443
456
  * [PauseRollupTxInput](#GraphQLClient.PauseRollupTxInput) : `Object`
444
457
  * [ResumeRollupTxInput](#GraphQLClient.ResumeRollupTxInput) : `Object`
445
- * [ReturnStakeTxInput](#GraphQLClient.ReturnStakeTxInput) : `Object`
446
- * [RevokeDelegateTxInput](#GraphQLClient.RevokeDelegateTxInput) : `Object`
447
- * [RevokeStakeTxInput](#GraphQLClient.RevokeStakeTxInput) : `Object`
448
- * [SlashStakeTxInput](#GraphQLClient.SlashStakeTxInput) : `Object`
449
- * [StakeTxInput](#GraphQLClient.StakeTxInput) : `Object`
450
- * [TransferTxInput](#GraphQLClient.TransferTxInput) : `Object`
451
- * [TransferV2TxInput](#GraphQLClient.TransferV2TxInput) : `Object`
452
- * [TransferV3TxInput](#GraphQLClient.TransferV3TxInput) : `Object`
453
- * [UpdateAssetTxInput](#GraphQLClient.UpdateAssetTxInput) : `Object`
454
- * [UpdateRollupTxInput](#GraphQLClient.UpdateRollupTxInput) : `Object`
455
- * [UpdateTokenFactoryTxInput](#GraphQLClient.UpdateTokenFactoryTxInput) : `Object`
456
- * [UpgradeNodeTxInput](#GraphQLClient.UpgradeNodeTxInput) : `Object`
458
+ * [CloseRollupTxInput](#GraphQLClient.CloseRollupTxInput) : `Object`
459
+ * [MigrateRollupTxInput](#GraphQLClient.MigrateRollupTxInput) : `Object`
460
+ * [DepositTokenV2TxInput](#GraphQLClient.DepositTokenV2TxInput) : `Object`
457
461
  * [WithdrawTokenV2TxInput](#GraphQLClient.WithdrawTokenV2TxInput) : `Object`
462
+ * [CreateTokenFactoryTxInput](#GraphQLClient.CreateTokenFactoryTxInput) : `Object`
463
+ * [UpdateTokenFactoryTxInput](#GraphQLClient.UpdateTokenFactoryTxInput) : `Object`
464
+ * [MintTokenTxInput](#GraphQLClient.MintTokenTxInput) : `Object`
465
+ * [BurnTokenTxInput](#GraphQLClient.BurnTokenTxInput) : `Object`
458
466
 
459
- ### new GraphQLClient(endpoint, autoInit)
467
+ ### new GraphQLClient(endpoint, autoInit, \[options])
460
468
 
461
469
  Create an instance of GraphQLClient
462
470
 
463
- | Param | Type | Default | Description |
464
- | -------- | --------- | ------- | --------------------------------- |
465
- | endpoint | `string` | | the graphql endpoint of the chain |
466
- | autoInit | `boolean` | `true` | whether auto warmup context |
471
+ | Param | Type | Default | Description |
472
+ | --------- | --------- | ------- | --------------------------------- |
473
+ | endpoint | `string` | | the graphql endpoint of the chain |
474
+ | autoInit | `boolean` | `true` | whether auto warmup context |
475
+ | [options] | `object` | | reserved for future use |
467
476
 
468
477
  **Example**
469
478
 
@@ -878,413 +887,413 @@ Send AccountMigrateTx transaction and get the hash, use [getTx](#GraphQLClient+g
878
887
  | params | [`AccountMigrateTxInput`](#GraphQLClient.AccountMigrateTxInput) |
879
888
  | extra | `object` |
880
889
 
881
- ### graphQLClient.sendAcquireAssetV2Tx(params, extra) ⇒ `Promise.<string>`
890
+ ### graphQLClient.sendDelegateTx(params, extra) ⇒ `Promise.<string>`
882
891
 
883
- Send AcquireAssetV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
892
+ Send DelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
884
893
 
885
894
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
886
895
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
887
896
 
888
- | Param | Type |
889
- | ------ | --------------------------------------------------------------- |
890
- | params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |
891
- | extra | `object` |
897
+ | Param | Type |
898
+ | ------ | --------------------------------------------------- |
899
+ | params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |
900
+ | extra | `object` |
892
901
 
893
- ### graphQLClient.sendAcquireAssetV3Tx(params, extra) ⇒ `Promise.<string>`
902
+ ### graphQLClient.sendRevokeDelegateTx(params, extra) ⇒ `Promise.<string>`
894
903
 
895
- Send AcquireAssetV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
904
+ Send RevokeDelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
896
905
 
897
906
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
898
907
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
899
908
 
900
909
  | Param | Type |
901
910
  | ------ | --------------------------------------------------------------- |
902
- | params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |
911
+ | params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |
903
912
  | extra | `object` |
904
913
 
905
- ### graphQLClient.sendBurnTokenTx(params, extra) ⇒ `Promise.<string>`
914
+ ### graphQLClient.sendUpgradeNodeTx(params, extra) ⇒ `Promise.<string>`
906
915
 
907
- Send BurnTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
916
+ Send UpgradeNodeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
908
917
 
909
918
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
910
919
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
911
920
 
912
- | Param | Type |
913
- | ------ | ----------------------------------------------------- |
914
- | params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |
915
- | extra | `object` |
921
+ | Param | Type |
922
+ | ------ | --------------------------------------------------------- |
923
+ | params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |
924
+ | extra | `object` |
916
925
 
917
- ### graphQLClient.sendClaimBlockRewardTx(params, extra) ⇒ `Promise.<string>`
926
+ ### graphQLClient.sendExchangeTx(params, extra) ⇒ `Promise.<string>`
918
927
 
919
- Send ClaimBlockRewardTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
928
+ Send ExchangeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
920
929
 
921
930
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
922
931
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
923
932
 
924
- | Param | Type |
925
- | ------ | ------------------------------------------------------------------- |
926
- | params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |
927
- | extra | `object` |
933
+ | Param | Type |
934
+ | ------ | --------------------------------------------------- |
935
+ | params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |
936
+ | extra | `object` |
928
937
 
929
- ### graphQLClient.sendClaimStakeTx(params, extra) ⇒ `Promise.<string>`
938
+ ### graphQLClient.sendExchangeV2Tx(params, extra) ⇒ `Promise.<string>`
930
939
 
931
- Send ClaimStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
940
+ Send ExchangeV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
932
941
 
933
942
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
934
943
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
935
944
 
936
945
  | Param | Type |
937
946
  | ------ | ------------------------------------------------------- |
938
- | params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |
947
+ | params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |
939
948
  | extra | `object` |
940
949
 
941
- ### graphQLClient.sendCloseRollupTx(params, extra) ⇒ `Promise.<string>`
950
+ ### graphQLClient.sendTransferTx(params, extra) ⇒ `Promise.<string>`
942
951
 
943
- Send CloseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
952
+ Send TransferTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
944
953
 
945
954
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
946
955
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
947
956
 
948
- | Param | Type |
949
- | ------ | --------------------------------------------------------- |
950
- | params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |
951
- | extra | `object` |
957
+ | Param | Type |
958
+ | ------ | --------------------------------------------------- |
959
+ | params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |
960
+ | extra | `object` |
952
961
 
953
- ### graphQLClient.sendConsumeAssetTx(params, extra) ⇒ `Promise.<string>`
962
+ ### graphQLClient.sendTransferV2Tx(params, extra) ⇒ `Promise.<string>`
954
963
 
955
- Send ConsumeAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
964
+ Send TransferV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
956
965
 
957
966
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
958
967
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
959
968
 
960
- | Param | Type |
961
- | ------ | ----------------------------------------------------------- |
962
- | params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |
963
- | extra | `object` |
969
+ | Param | Type |
970
+ | ------ | ------------------------------------------------------- |
971
+ | params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |
972
+ | extra | `object` |
964
973
 
965
- ### graphQLClient.sendCreateAssetTx(params, extra) ⇒ `Promise.<string>`
974
+ ### graphQLClient.sendTransferV3Tx(params, extra) ⇒ `Promise.<string>`
966
975
 
967
- Send CreateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
976
+ Send TransferV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
968
977
 
969
978
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
970
979
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
971
980
 
972
- | Param | Type |
973
- | ------ | --------------------------------------------------------- |
974
- | params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |
975
- | extra | `object` |
981
+ | Param | Type |
982
+ | ------ | ------------------------------------------------------- |
983
+ | params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |
984
+ | extra | `object` |
976
985
 
977
- ### graphQLClient.sendCreateFactoryTx(params, extra) ⇒ `Promise.<string>`
986
+ ### graphQLClient.sendCreateTokenTx(params, extra) ⇒ `Promise.<string>`
978
987
 
979
- Send CreateFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
988
+ Send CreateTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
980
989
 
981
990
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
982
991
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
983
992
 
984
- | Param | Type |
985
- | ------ | ------------------------------------------------------------- |
986
- | params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |
987
- | extra | `object` |
988
-
989
- ### graphQLClient.sendCreateRollupBlockTx(params, extra) ⇒ `Promise.<string>`
993
+ | Param | Type |
994
+ | ------ | --------------------------------------------------------- |
995
+ | params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |
996
+ | extra | `object` |
990
997
 
991
- Send CreateRollupBlockTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
998
+ ### graphQLClient.sendAcquireAssetV2Tx(params, extra) ⇒ `Promise.<string>`
999
+
1000
+ Send AcquireAssetV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
992
1001
 
993
1002
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
994
1003
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
995
1004
 
996
- | Param | Type |
997
- | ------ | --------------------------------------------------------------------- |
998
- | params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |
999
- | extra | `object` |
1005
+ | Param | Type |
1006
+ | ------ | --------------------------------------------------------------- |
1007
+ | params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |
1008
+ | extra | `object` |
1000
1009
 
1001
- ### graphQLClient.sendCreateRollupTx(params, extra) ⇒ `Promise.<string>`
1010
+ ### graphQLClient.sendAcquireAssetV3Tx(params, extra) ⇒ `Promise.<string>`
1002
1011
 
1003
- Send CreateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1012
+ Send AcquireAssetV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1004
1013
 
1005
1014
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1006
1015
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1007
1016
 
1008
- | Param | Type |
1009
- | ------ | ----------------------------------------------------------- |
1010
- | params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |
1011
- | extra | `object` |
1017
+ | Param | Type |
1018
+ | ------ | --------------------------------------------------------------- |
1019
+ | params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |
1020
+ | extra | `object` |
1012
1021
 
1013
- ### graphQLClient.sendCreateTokenFactoryTx(params, extra) ⇒ `Promise.<string>`
1022
+ ### graphQLClient.sendMintAssetTx(params, extra) ⇒ `Promise.<string>`
1014
1023
 
1015
- Send CreateTokenFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1024
+ Send MintAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1016
1025
 
1017
1026
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1018
1027
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1019
1028
 
1020
- | Param | Type |
1021
- | ------ | ----------------------------------------------------------------------- |
1022
- | params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |
1023
- | extra | `object` |
1029
+ | Param | Type |
1030
+ | ------ | ----------------------------------------------------- |
1031
+ | params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |
1032
+ | extra | `object` |
1024
1033
 
1025
- ### graphQLClient.sendCreateTokenTx(params, extra) ⇒ `Promise.<string>`
1034
+ ### graphQLClient.sendCreateAssetTx(params, extra) ⇒ `Promise.<string>`
1026
1035
 
1027
- Send CreateTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1036
+ Send CreateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1028
1037
 
1029
1038
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1030
1039
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1031
1040
 
1032
1041
  | Param | Type |
1033
1042
  | ------ | --------------------------------------------------------- |
1034
- | params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |
1043
+ | params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |
1035
1044
  | extra | `object` |
1036
1045
 
1037
- ### graphQLClient.sendDelegateTx(params, extra) ⇒ `Promise.<string>`
1046
+ ### graphQLClient.sendUpdateAssetTx(params, extra) ⇒ `Promise.<string>`
1038
1047
 
1039
- Send DelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1048
+ Send UpdateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1040
1049
 
1041
1050
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1042
1051
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1043
1052
 
1044
- | Param | Type |
1045
- | ------ | --------------------------------------------------- |
1046
- | params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |
1047
- | extra | `object` |
1053
+ | Param | Type |
1054
+ | ------ | --------------------------------------------------------- |
1055
+ | params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |
1056
+ | extra | `object` |
1048
1057
 
1049
- ### graphQLClient.sendDepositTokenV2Tx(params, extra) ⇒ `Promise.<string>`
1058
+ ### graphQLClient.sendConsumeAssetTx(params, extra) ⇒ `Promise.<string>`
1050
1059
 
1051
- Send DepositTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1060
+ Send ConsumeAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1052
1061
 
1053
1062
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1054
1063
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1055
1064
 
1056
- | Param | Type |
1057
- | ------ | --------------------------------------------------------------- |
1058
- | params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |
1059
- | extra | `object` |
1065
+ | Param | Type |
1066
+ | ------ | ----------------------------------------------------------- |
1067
+ | params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |
1068
+ | extra | `object` |
1060
1069
 
1061
- ### graphQLClient.sendExchangeTx(params, extra) ⇒ `Promise.<string>`
1070
+ ### graphQLClient.sendCreateFactoryTx(params, extra) ⇒ `Promise.<string>`
1062
1071
 
1063
- Send ExchangeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1072
+ Send CreateFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1064
1073
 
1065
1074
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1066
1075
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1067
1076
 
1068
- | Param | Type |
1069
- | ------ | --------------------------------------------------- |
1070
- | params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |
1071
- | extra | `object` |
1077
+ | Param | Type |
1078
+ | ------ | ------------------------------------------------------------- |
1079
+ | params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |
1080
+ | extra | `object` |
1072
1081
 
1073
- ### graphQLClient.sendExchangeV2Tx(params, extra) ⇒ `Promise.<string>`
1082
+ ### graphQLClient.sendStakeTx(params, extra) ⇒ `Promise.<string>`
1074
1083
 
1075
- Send ExchangeV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1084
+ Send StakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1085
+
1086
+ **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1087
+ **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1088
+
1089
+ | Param | Type |
1090
+ | ------ | --------------------------------------------- |
1091
+ | params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |
1092
+ | extra | `object` |
1093
+
1094
+ ### graphQLClient.sendRevokeStakeTx(params, extra) ⇒ `Promise.<string>`
1095
+
1096
+ Send RevokeStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1097
+
1098
+ **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1099
+ **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1100
+
1101
+ | Param | Type |
1102
+ | ------ | --------------------------------------------------------- |
1103
+ | params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |
1104
+ | extra | `object` |
1105
+
1106
+ ### graphQLClient.sendClaimStakeTx(params, extra) ⇒ `Promise.<string>`
1107
+
1108
+ Send ClaimStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1076
1109
 
1077
1110
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1078
1111
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1079
1112
 
1080
1113
  | Param | Type |
1081
1114
  | ------ | ------------------------------------------------------- |
1082
- | params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |
1115
+ | params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |
1083
1116
  | extra | `object` |
1084
1117
 
1085
- ### graphQLClient.sendJoinRollupTx(params, extra) ⇒ `Promise.<string>`
1118
+ ### graphQLClient.sendSlashStakeTx(params, extra) ⇒ `Promise.<string>`
1086
1119
 
1087
- Send JoinRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1120
+ Send SlashStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1088
1121
 
1089
1122
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1090
1123
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1091
1124
 
1092
1125
  | Param | Type |
1093
1126
  | ------ | ------------------------------------------------------- |
1094
- | params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |
1127
+ | params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |
1095
1128
  | extra | `object` |
1096
1129
 
1097
- ### graphQLClient.sendLeaveRollupTx(params, extra) ⇒ `Promise.<string>`
1130
+ ### graphQLClient.sendReturnStakeTx(params, extra) ⇒ `Promise.<string>`
1098
1131
 
1099
- Send LeaveRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1132
+ Send ReturnStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1100
1133
 
1101
1134
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1102
1135
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1103
1136
 
1104
1137
  | Param | Type |
1105
1138
  | ------ | --------------------------------------------------------- |
1106
- | params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |
1139
+ | params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |
1107
1140
  | extra | `object` |
1108
1141
 
1109
- ### graphQLClient.sendMigrateRollupTx(params, extra) ⇒ `Promise.<string>`
1142
+ ### graphQLClient.sendCreateRollupTx(params, extra) ⇒ `Promise.<string>`
1110
1143
 
1111
- Send MigrateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1144
+ Send CreateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1112
1145
 
1113
1146
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1114
1147
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1115
1148
 
1116
- | Param | Type |
1117
- | ------ | ------------------------------------------------------------- |
1118
- | params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |
1119
- | extra | `object` |
1149
+ | Param | Type |
1150
+ | ------ | ----------------------------------------------------------- |
1151
+ | params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |
1152
+ | extra | `object` |
1120
1153
 
1121
- ### graphQLClient.sendMintAssetTx(params, extra) ⇒ `Promise.<string>`
1154
+ ### graphQLClient.sendUpdateRollupTx(params, extra) ⇒ `Promise.<string>`
1122
1155
 
1123
- Send MintAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1156
+ Send UpdateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1124
1157
 
1125
1158
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1126
1159
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1127
1160
 
1128
- | Param | Type |
1129
- | ------ | ----------------------------------------------------- |
1130
- | params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |
1131
- | extra | `object` |
1161
+ | Param | Type |
1162
+ | ------ | ----------------------------------------------------------- |
1163
+ | params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |
1164
+ | extra | `object` |
1132
1165
 
1133
- ### graphQLClient.sendMintTokenTx(params, extra) ⇒ `Promise.<string>`
1166
+ ### graphQLClient.sendJoinRollupTx(params, extra) ⇒ `Promise.<string>`
1134
1167
 
1135
- Send MintTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1168
+ Send JoinRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1136
1169
 
1137
1170
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1138
1171
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1139
1172
 
1140
- | Param | Type |
1141
- | ------ | ----------------------------------------------------- |
1142
- | params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |
1143
- | extra | `object` |
1173
+ | Param | Type |
1174
+ | ------ | ------------------------------------------------------- |
1175
+ | params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |
1176
+ | extra | `object` |
1144
1177
 
1145
- ### graphQLClient.sendPauseRollupTx(params, extra) ⇒ `Promise.<string>`
1178
+ ### graphQLClient.sendLeaveRollupTx(params, extra) ⇒ `Promise.<string>`
1146
1179
 
1147
- Send PauseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1180
+ Send LeaveRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1148
1181
 
1149
1182
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1150
1183
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1151
1184
 
1152
1185
  | Param | Type |
1153
1186
  | ------ | --------------------------------------------------------- |
1154
- | params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |
1187
+ | params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |
1155
1188
  | extra | `object` |
1156
1189
 
1157
- ### graphQLClient.sendResumeRollupTx(params, extra) ⇒ `Promise.<string>`
1190
+ ### graphQLClient.sendCreateRollupBlockTx(params, extra) ⇒ `Promise.<string>`
1158
1191
 
1159
- Send ResumeRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1192
+ Send CreateRollupBlockTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1160
1193
 
1161
1194
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1162
1195
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1163
1196
 
1164
- | Param | Type |
1165
- | ------ | ----------------------------------------------------------- |
1166
- | params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |
1167
- | extra | `object` |
1197
+ | Param | Type |
1198
+ | ------ | --------------------------------------------------------------------- |
1199
+ | params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |
1200
+ | extra | `object` |
1168
1201
 
1169
- ### graphQLClient.sendReturnStakeTx(params, extra) ⇒ `Promise.<string>`
1202
+ ### graphQLClient.sendClaimBlockRewardTx(params, extra) ⇒ `Promise.<string>`
1170
1203
 
1171
- Send ReturnStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1204
+ Send ClaimBlockRewardTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1205
+
1206
+ **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1207
+ **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1208
+
1209
+ | Param | Type |
1210
+ | ------ | ------------------------------------------------------------------- |
1211
+ | params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |
1212
+ | extra | `object` |
1213
+
1214
+ ### graphQLClient.sendPauseRollupTx(params, extra) ⇒ `Promise.<string>`
1215
+
1216
+ Send PauseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1172
1217
 
1173
1218
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1174
1219
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1175
1220
 
1176
1221
  | Param | Type |
1177
1222
  | ------ | --------------------------------------------------------- |
1178
- | params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |
1223
+ | params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |
1179
1224
  | extra | `object` |
1180
1225
 
1181
- ### graphQLClient.sendRevokeDelegateTx(params, extra) ⇒ `Promise.<string>`
1226
+ ### graphQLClient.sendResumeRollupTx(params, extra) ⇒ `Promise.<string>`
1182
1227
 
1183
- Send RevokeDelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1228
+ Send ResumeRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1184
1229
 
1185
1230
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1186
1231
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1187
1232
 
1188
- | Param | Type |
1189
- | ------ | --------------------------------------------------------------- |
1190
- | params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |
1191
- | extra | `object` |
1233
+ | Param | Type |
1234
+ | ------ | ----------------------------------------------------------- |
1235
+ | params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |
1236
+ | extra | `object` |
1192
1237
 
1193
- ### graphQLClient.sendRevokeStakeTx(params, extra) ⇒ `Promise.<string>`
1238
+ ### graphQLClient.sendCloseRollupTx(params, extra) ⇒ `Promise.<string>`
1194
1239
 
1195
- Send RevokeStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1240
+ Send CloseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1196
1241
 
1197
1242
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1198
1243
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1199
1244
 
1200
1245
  | Param | Type |
1201
1246
  | ------ | --------------------------------------------------------- |
1202
- | params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |
1247
+ | params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |
1203
1248
  | extra | `object` |
1204
1249
 
1205
- ### graphQLClient.sendSlashStakeTx(params, extra) ⇒ `Promise.<string>`
1250
+ ### graphQLClient.sendMigrateRollupTx(params, extra) ⇒ `Promise.<string>`
1206
1251
 
1207
- Send SlashStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1252
+ Send MigrateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1208
1253
 
1209
1254
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1210
1255
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1211
1256
 
1212
- | Param | Type |
1213
- | ------ | ------------------------------------------------------- |
1214
- | params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |
1215
- | extra | `object` |
1257
+ | Param | Type |
1258
+ | ------ | ------------------------------------------------------------- |
1259
+ | params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |
1260
+ | extra | `object` |
1216
1261
 
1217
- ### graphQLClient.sendStakeTx(params, extra) ⇒ `Promise.<string>`
1262
+ ### graphQLClient.sendDepositTokenV2Tx(params, extra) ⇒ `Promise.<string>`
1218
1263
 
1219
- Send StakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1264
+ Send DepositTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1220
1265
 
1221
1266
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1222
1267
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1223
1268
 
1224
- | Param | Type |
1225
- | ------ | --------------------------------------------- |
1226
- | params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |
1227
- | extra | `object` |
1269
+ | Param | Type |
1270
+ | ------ | --------------------------------------------------------------- |
1271
+ | params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |
1272
+ | extra | `object` |
1228
1273
 
1229
- ### graphQLClient.sendTransferTx(params, extra) ⇒ `Promise.<string>`
1274
+ ### graphQLClient.sendWithdrawTokenV2Tx(params, extra) ⇒ `Promise.<string>`
1230
1275
 
1231
- Send TransferTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1276
+ Send WithdrawTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1232
1277
 
1233
1278
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1234
1279
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1235
1280
 
1236
- | Param | Type |
1237
- | ------ | --------------------------------------------------- |
1238
- | params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |
1239
- | extra | `object` |
1281
+ | Param | Type |
1282
+ | ------ | ----------------------------------------------------------------- |
1283
+ | params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |
1284
+ | extra | `object` |
1240
1285
 
1241
- ### graphQLClient.sendTransferV2Tx(params, extra) ⇒ `Promise.<string>`
1286
+ ### graphQLClient.sendCreateTokenFactoryTx(params, extra) ⇒ `Promise.<string>`
1242
1287
 
1243
- Send TransferV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1288
+ Send CreateTokenFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1244
1289
 
1245
1290
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1246
1291
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1247
1292
 
1248
- | Param | Type |
1249
- | ------ | ------------------------------------------------------- |
1250
- | params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |
1251
- | extra | `object` |
1252
-
1253
- ### graphQLClient.sendTransferV3Tx(params, extra) ⇒ `Promise.<string>`
1254
-
1255
- Send TransferV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1256
-
1257
- **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1258
- **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1259
-
1260
- | Param | Type |
1261
- | ------ | ------------------------------------------------------- |
1262
- | params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |
1263
- | extra | `object` |
1264
-
1265
- ### graphQLClient.sendUpdateAssetTx(params, extra) ⇒ `Promise.<string>`
1266
-
1267
- Send UpdateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1268
-
1269
- **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1270
- **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1271
-
1272
- | Param | Type |
1273
- | ------ | --------------------------------------------------------- |
1274
- | params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |
1275
- | extra | `object` |
1276
-
1277
- ### graphQLClient.sendUpdateRollupTx(params, extra) ⇒ `Promise.<string>`
1278
-
1279
- Send UpdateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1280
-
1281
- **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1282
- **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1283
-
1284
- | Param | Type |
1285
- | ------ | ----------------------------------------------------------- |
1286
- | params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |
1287
- | extra | `object` |
1293
+ | Param | Type |
1294
+ | ------ | ----------------------------------------------------------------------- |
1295
+ | params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |
1296
+ | extra | `object` |
1288
1297
 
1289
1298
  ### graphQLClient.sendUpdateTokenFactoryTx(params, extra) ⇒ `Promise.<string>`
1290
1299
 
@@ -1298,29 +1307,29 @@ Send UpdateTokenFactoryTx transaction and get the hash, use [getTx](#GraphQLClie
1298
1307
  | params | [`UpdateTokenFactoryTxInput`](#GraphQLClient.UpdateTokenFactoryTxInput) |
1299
1308
  | extra | `object` |
1300
1309
 
1301
- ### graphQLClient.sendUpgradeNodeTx(params, extra) ⇒ `Promise.<string>`
1310
+ ### graphQLClient.sendMintTokenTx(params, extra) ⇒ `Promise.<string>`
1302
1311
 
1303
- Send UpgradeNodeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1312
+ Send MintTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1304
1313
 
1305
1314
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1306
1315
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1307
1316
 
1308
- | Param | Type |
1309
- | ------ | --------------------------------------------------------- |
1310
- | params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |
1311
- | extra | `object` |
1317
+ | Param | Type |
1318
+ | ------ | ----------------------------------------------------- |
1319
+ | params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |
1320
+ | extra | `object` |
1312
1321
 
1313
- ### graphQLClient.sendWithdrawTokenV2Tx(params, extra) ⇒ `Promise.<string>`
1322
+ ### graphQLClient.sendBurnTokenTx(params, extra) ⇒ `Promise.<string>`
1314
1323
 
1315
- Send WithdrawTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1324
+ Send BurnTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail
1316
1325
 
1317
1326
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1318
1327
  **Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown
1319
1328
 
1320
- | Param | Type |
1321
- | ------ | ----------------------------------------------------------------- |
1322
- | params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |
1323
- | extra | `object` |
1329
+ | Param | Type |
1330
+ | ------ | ----------------------------------------------------- |
1331
+ | params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |
1332
+ | extra | `object` |
1324
1333
 
1325
1334
  ### graphQLClient.encodeAccountMigrateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1326
1335
 
@@ -1333,379 +1342,379 @@ Encode a AccountMigrateTx transaction for later use
1333
1342
  | ------ | --------------------------------------------------------------- |
1334
1343
  | params | [`AccountMigrateTxInput`](#GraphQLClient.AccountMigrateTxInput) |
1335
1344
 
1336
- ### graphQLClient.encodeAcquireAssetV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1345
+ ### graphQLClient.encodeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1337
1346
 
1338
- Encode a AcquireAssetV2Tx transaction for later use
1347
+ Encode a DelegateTx transaction for later use
1339
1348
 
1340
1349
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1341
1350
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1342
1351
 
1343
- | Param | Type |
1344
- | ------ | --------------------------------------------------------------- |
1345
- | params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |
1352
+ | Param | Type |
1353
+ | ------ | --------------------------------------------------- |
1354
+ | params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |
1346
1355
 
1347
- ### graphQLClient.encodeAcquireAssetV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1356
+ ### graphQLClient.encodeRevokeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1348
1357
 
1349
- Encode a AcquireAssetV3Tx transaction for later use
1358
+ Encode a RevokeDelegateTx transaction for later use
1350
1359
 
1351
1360
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1352
1361
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1353
1362
 
1354
1363
  | Param | Type |
1355
1364
  | ------ | --------------------------------------------------------------- |
1356
- | params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |
1365
+ | params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |
1357
1366
 
1358
- ### graphQLClient.encodeBurnTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1367
+ ### graphQLClient.encodeUpgradeNodeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1359
1368
 
1360
- Encode a BurnTokenTx transaction for later use
1369
+ Encode a UpgradeNodeTx transaction for later use
1361
1370
 
1362
1371
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1363
1372
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1364
1373
 
1365
- | Param | Type |
1366
- | ------ | ----------------------------------------------------- |
1367
- | params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |
1374
+ | Param | Type |
1375
+ | ------ | --------------------------------------------------------- |
1376
+ | params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |
1368
1377
 
1369
- ### graphQLClient.encodeClaimBlockRewardTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1378
+ ### graphQLClient.encodeExchangeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1370
1379
 
1371
- Encode a ClaimBlockRewardTx transaction for later use
1380
+ Encode a ExchangeTx transaction for later use
1372
1381
 
1373
1382
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1374
1383
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1375
1384
 
1376
- | Param | Type |
1377
- | ------ | ------------------------------------------------------------------- |
1378
- | params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |
1385
+ | Param | Type |
1386
+ | ------ | --------------------------------------------------- |
1387
+ | params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |
1379
1388
 
1380
- ### graphQLClient.encodeClaimStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1389
+ ### graphQLClient.encodeExchangeV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1381
1390
 
1382
- Encode a ClaimStakeTx transaction for later use
1391
+ Encode a ExchangeV2Tx transaction for later use
1383
1392
 
1384
1393
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1385
1394
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1386
1395
 
1387
1396
  | Param | Type |
1388
1397
  | ------ | ------------------------------------------------------- |
1389
- | params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |
1398
+ | params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |
1390
1399
 
1391
- ### graphQLClient.encodeCloseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1400
+ ### graphQLClient.encodeTransferTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1392
1401
 
1393
- Encode a CloseRollupTx transaction for later use
1402
+ Encode a TransferTx transaction for later use
1394
1403
 
1395
1404
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1396
1405
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1397
1406
 
1398
- | Param | Type |
1399
- | ------ | --------------------------------------------------------- |
1400
- | params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |
1407
+ | Param | Type |
1408
+ | ------ | --------------------------------------------------- |
1409
+ | params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |
1401
1410
 
1402
- ### graphQLClient.encodeConsumeAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1411
+ ### graphQLClient.encodeTransferV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1403
1412
 
1404
- Encode a ConsumeAssetTx transaction for later use
1413
+ Encode a TransferV2Tx transaction for later use
1405
1414
 
1406
1415
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1407
1416
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1408
1417
 
1409
- | Param | Type |
1410
- | ------ | ----------------------------------------------------------- |
1411
- | params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |
1418
+ | Param | Type |
1419
+ | ------ | ------------------------------------------------------- |
1420
+ | params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |
1412
1421
 
1413
- ### graphQLClient.encodeCreateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1422
+ ### graphQLClient.encodeTransferV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1414
1423
 
1415
- Encode a CreateAssetTx transaction for later use
1424
+ Encode a TransferV3Tx transaction for later use
1425
+
1426
+ **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1427
+ **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1428
+
1429
+ | Param | Type |
1430
+ | ------ | ------------------------------------------------------- |
1431
+ | params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |
1432
+
1433
+ ### graphQLClient.encodeCreateTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1434
+
1435
+ Encode a CreateTokenTx transaction for later use
1416
1436
 
1417
1437
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1418
1438
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1419
1439
 
1420
1440
  | Param | Type |
1421
1441
  | ------ | --------------------------------------------------------- |
1422
- | params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |
1442
+ | params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |
1423
1443
 
1424
- ### graphQLClient.encodeCreateFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1444
+ ### graphQLClient.encodeAcquireAssetV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1425
1445
 
1426
- Encode a CreateFactoryTx transaction for later use
1446
+ Encode a AcquireAssetV2Tx transaction for later use
1427
1447
 
1428
1448
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1429
1449
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1430
1450
 
1431
- | Param | Type |
1432
- | ------ | ------------------------------------------------------------- |
1433
- | params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |
1451
+ | Param | Type |
1452
+ | ------ | --------------------------------------------------------------- |
1453
+ | params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |
1434
1454
 
1435
- ### graphQLClient.encodeCreateRollupBlockTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1455
+ ### graphQLClient.encodeAcquireAssetV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1436
1456
 
1437
- Encode a CreateRollupBlockTx transaction for later use
1457
+ Encode a AcquireAssetV3Tx transaction for later use
1438
1458
 
1439
1459
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1440
1460
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1441
1461
 
1442
- | Param | Type |
1443
- | ------ | --------------------------------------------------------------------- |
1444
- | params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |
1462
+ | Param | Type |
1463
+ | ------ | --------------------------------------------------------------- |
1464
+ | params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |
1445
1465
 
1446
- ### graphQLClient.encodeCreateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1466
+ ### graphQLClient.encodeMintAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1447
1467
 
1448
- Encode a CreateRollupTx transaction for later use
1468
+ Encode a MintAssetTx transaction for later use
1449
1469
 
1450
1470
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1451
1471
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1452
1472
 
1453
- | Param | Type |
1454
- | ------ | ----------------------------------------------------------- |
1455
- | params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |
1473
+ | Param | Type |
1474
+ | ------ | ----------------------------------------------------- |
1475
+ | params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |
1456
1476
 
1457
- ### graphQLClient.encodeCreateTokenFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1477
+ ### graphQLClient.encodeCreateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1458
1478
 
1459
- Encode a CreateTokenFactoryTx transaction for later use
1479
+ Encode a CreateAssetTx transaction for later use
1460
1480
 
1461
1481
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1462
1482
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1463
1483
 
1464
- | Param | Type |
1465
- | ------ | ----------------------------------------------------------------------- |
1466
- | params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |
1484
+ | Param | Type |
1485
+ | ------ | --------------------------------------------------------- |
1486
+ | params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |
1467
1487
 
1468
- ### graphQLClient.encodeCreateTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1488
+ ### graphQLClient.encodeUpdateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1469
1489
 
1470
- Encode a CreateTokenTx transaction for later use
1490
+ Encode a UpdateAssetTx transaction for later use
1471
1491
 
1472
1492
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1473
1493
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1474
1494
 
1475
1495
  | Param | Type |
1476
1496
  | ------ | --------------------------------------------------------- |
1477
- | params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |
1497
+ | params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |
1478
1498
 
1479
- ### graphQLClient.encodeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1499
+ ### graphQLClient.encodeConsumeAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1480
1500
 
1481
- Encode a DelegateTx transaction for later use
1501
+ Encode a ConsumeAssetTx transaction for later use
1482
1502
 
1483
1503
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1484
1504
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1485
1505
 
1486
- | Param | Type |
1487
- | ------ | --------------------------------------------------- |
1488
- | params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |
1506
+ | Param | Type |
1507
+ | ------ | ----------------------------------------------------------- |
1508
+ | params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |
1489
1509
 
1490
- ### graphQLClient.encodeDepositTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1510
+ ### graphQLClient.encodeCreateFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1491
1511
 
1492
- Encode a DepositTokenV2Tx transaction for later use
1512
+ Encode a CreateFactoryTx transaction for later use
1493
1513
 
1494
1514
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1495
1515
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1496
1516
 
1497
- | Param | Type |
1498
- | ------ | --------------------------------------------------------------- |
1499
- | params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |
1517
+ | Param | Type |
1518
+ | ------ | ------------------------------------------------------------- |
1519
+ | params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |
1500
1520
 
1501
- ### graphQLClient.encodeExchangeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1521
+ ### graphQLClient.encodeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1502
1522
 
1503
- Encode a ExchangeTx transaction for later use
1523
+ Encode a StakeTx transaction for later use
1504
1524
 
1505
1525
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1506
1526
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1507
1527
 
1508
- | Param | Type |
1509
- | ------ | --------------------------------------------------- |
1510
- | params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |
1528
+ | Param | Type |
1529
+ | ------ | --------------------------------------------- |
1530
+ | params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |
1511
1531
 
1512
- ### graphQLClient.encodeExchangeV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1532
+ ### graphQLClient.encodeRevokeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1513
1533
 
1514
- Encode a ExchangeV2Tx transaction for later use
1534
+ Encode a RevokeStakeTx transaction for later use
1535
+
1536
+ **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1537
+ **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1538
+
1539
+ | Param | Type |
1540
+ | ------ | --------------------------------------------------------- |
1541
+ | params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |
1542
+
1543
+ ### graphQLClient.encodeClaimStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1544
+
1545
+ Encode a ClaimStakeTx transaction for later use
1515
1546
 
1516
1547
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1517
1548
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1518
1549
 
1519
1550
  | Param | Type |
1520
1551
  | ------ | ------------------------------------------------------- |
1521
- | params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |
1552
+ | params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |
1522
1553
 
1523
- ### graphQLClient.encodeJoinRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1554
+ ### graphQLClient.encodeSlashStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1524
1555
 
1525
- Encode a JoinRollupTx transaction for later use
1556
+ Encode a SlashStakeTx transaction for later use
1526
1557
 
1527
1558
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1528
1559
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1529
1560
 
1530
1561
  | Param | Type |
1531
1562
  | ------ | ------------------------------------------------------- |
1532
- | params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |
1563
+ | params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |
1533
1564
 
1534
- ### graphQLClient.encodeLeaveRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1565
+ ### graphQLClient.encodeReturnStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1535
1566
 
1536
- Encode a LeaveRollupTx transaction for later use
1567
+ Encode a ReturnStakeTx transaction for later use
1537
1568
 
1538
1569
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1539
1570
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1540
1571
 
1541
1572
  | Param | Type |
1542
1573
  | ------ | --------------------------------------------------------- |
1543
- | params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |
1574
+ | params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |
1544
1575
 
1545
- ### graphQLClient.encodeMigrateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1576
+ ### graphQLClient.encodeCreateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1546
1577
 
1547
- Encode a MigrateRollupTx transaction for later use
1578
+ Encode a CreateRollupTx transaction for later use
1548
1579
 
1549
1580
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1550
1581
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1551
1582
 
1552
- | Param | Type |
1553
- | ------ | ------------------------------------------------------------- |
1554
- | params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |
1583
+ | Param | Type |
1584
+ | ------ | ----------------------------------------------------------- |
1585
+ | params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |
1555
1586
 
1556
- ### graphQLClient.encodeMintAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1587
+ ### graphQLClient.encodeUpdateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1557
1588
 
1558
- Encode a MintAssetTx transaction for later use
1589
+ Encode a UpdateRollupTx transaction for later use
1559
1590
 
1560
1591
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1561
1592
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1562
1593
 
1563
- | Param | Type |
1564
- | ------ | ----------------------------------------------------- |
1565
- | params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |
1594
+ | Param | Type |
1595
+ | ------ | ----------------------------------------------------------- |
1596
+ | params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |
1566
1597
 
1567
- ### graphQLClient.encodeMintTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1598
+ ### graphQLClient.encodeJoinRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1568
1599
 
1569
- Encode a MintTokenTx transaction for later use
1600
+ Encode a JoinRollupTx transaction for later use
1570
1601
 
1571
1602
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1572
1603
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1573
1604
 
1574
- | Param | Type |
1575
- | ------ | ----------------------------------------------------- |
1576
- | params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |
1605
+ | Param | Type |
1606
+ | ------ | ------------------------------------------------------- |
1607
+ | params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |
1577
1608
 
1578
- ### graphQLClient.encodePauseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1609
+ ### graphQLClient.encodeLeaveRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1579
1610
 
1580
- Encode a PauseRollupTx transaction for later use
1611
+ Encode a LeaveRollupTx transaction for later use
1581
1612
 
1582
1613
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1583
1614
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1584
1615
 
1585
1616
  | Param | Type |
1586
1617
  | ------ | --------------------------------------------------------- |
1587
- | params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |
1588
-
1589
- ### graphQLClient.encodeResumeRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1590
-
1591
- Encode a ResumeRollupTx transaction for later use
1592
-
1593
- **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1594
- **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1595
-
1596
- | Param | Type |
1597
- | ------ | ----------------------------------------------------------- |
1598
- | params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |
1618
+ | params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |
1599
1619
 
1600
- ### graphQLClient.encodeReturnStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1620
+ ### graphQLClient.encodeCreateRollupBlockTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1601
1621
 
1602
- Encode a ReturnStakeTx transaction for later use
1622
+ Encode a CreateRollupBlockTx transaction for later use
1603
1623
 
1604
1624
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1605
1625
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1606
1626
 
1607
- | Param | Type |
1608
- | ------ | --------------------------------------------------------- |
1609
- | params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |
1627
+ | Param | Type |
1628
+ | ------ | --------------------------------------------------------------------- |
1629
+ | params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |
1610
1630
 
1611
- ### graphQLClient.encodeRevokeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1631
+ ### graphQLClient.encodeClaimBlockRewardTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1612
1632
 
1613
- Encode a RevokeDelegateTx transaction for later use
1633
+ Encode a ClaimBlockRewardTx transaction for later use
1614
1634
 
1615
1635
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1616
1636
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1617
1637
 
1618
- | Param | Type |
1619
- | ------ | --------------------------------------------------------------- |
1620
- | params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |
1638
+ | Param | Type |
1639
+ | ------ | ------------------------------------------------------------------- |
1640
+ | params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |
1621
1641
 
1622
- ### graphQLClient.encodeRevokeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1642
+ ### graphQLClient.encodePauseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1623
1643
 
1624
- Encode a RevokeStakeTx transaction for later use
1644
+ Encode a PauseRollupTx transaction for later use
1625
1645
 
1626
1646
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1627
1647
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1628
1648
 
1629
1649
  | Param | Type |
1630
1650
  | ------ | --------------------------------------------------------- |
1631
- | params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |
1632
-
1633
- ### graphQLClient.encodeSlashStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1634
-
1635
- Encode a SlashStakeTx transaction for later use
1636
-
1637
- **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1638
- **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1639
-
1640
- | Param | Type |
1641
- | ------ | ------------------------------------------------------- |
1642
- | params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |
1651
+ | params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |
1643
1652
 
1644
- ### graphQLClient.encodeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1653
+ ### graphQLClient.encodeResumeRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1645
1654
 
1646
- Encode a StakeTx transaction for later use
1655
+ Encode a ResumeRollupTx transaction for later use
1647
1656
 
1648
1657
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1649
1658
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1650
1659
 
1651
- | Param | Type |
1652
- | ------ | --------------------------------------------- |
1653
- | params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |
1660
+ | Param | Type |
1661
+ | ------ | ----------------------------------------------------------- |
1662
+ | params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |
1654
1663
 
1655
- ### graphQLClient.encodeTransferTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1664
+ ### graphQLClient.encodeCloseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1656
1665
 
1657
- Encode a TransferTx transaction for later use
1666
+ Encode a CloseRollupTx transaction for later use
1658
1667
 
1659
1668
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1660
1669
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1661
1670
 
1662
- | Param | Type |
1663
- | ------ | --------------------------------------------------- |
1664
- | params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |
1671
+ | Param | Type |
1672
+ | ------ | --------------------------------------------------------- |
1673
+ | params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |
1665
1674
 
1666
- ### graphQLClient.encodeTransferV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1675
+ ### graphQLClient.encodeMigrateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1667
1676
 
1668
- Encode a TransferV2Tx transaction for later use
1677
+ Encode a MigrateRollupTx transaction for later use
1669
1678
 
1670
1679
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1671
1680
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1672
1681
 
1673
- | Param | Type |
1674
- | ------ | ------------------------------------------------------- |
1675
- | params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |
1682
+ | Param | Type |
1683
+ | ------ | ------------------------------------------------------------- |
1684
+ | params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |
1676
1685
 
1677
- ### graphQLClient.encodeTransferV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1686
+ ### graphQLClient.encodeDepositTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1678
1687
 
1679
- Encode a TransferV3Tx transaction for later use
1688
+ Encode a DepositTokenV2Tx transaction for later use
1680
1689
 
1681
1690
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1682
1691
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1683
1692
 
1684
- | Param | Type |
1685
- | ------ | ------------------------------------------------------- |
1686
- | params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |
1693
+ | Param | Type |
1694
+ | ------ | --------------------------------------------------------------- |
1695
+ | params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |
1687
1696
 
1688
- ### graphQLClient.encodeUpdateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1697
+ ### graphQLClient.encodeWithdrawTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1689
1698
 
1690
- Encode a UpdateAssetTx transaction for later use
1699
+ Encode a WithdrawTokenV2Tx transaction for later use
1691
1700
 
1692
1701
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1693
1702
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1694
1703
 
1695
- | Param | Type |
1696
- | ------ | --------------------------------------------------------- |
1697
- | params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |
1704
+ | Param | Type |
1705
+ | ------ | ----------------------------------------------------------------- |
1706
+ | params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |
1698
1707
 
1699
- ### graphQLClient.encodeUpdateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1708
+ ### graphQLClient.encodeCreateTokenFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1700
1709
 
1701
- Encode a UpdateRollupTx transaction for later use
1710
+ Encode a CreateTokenFactoryTx transaction for later use
1702
1711
 
1703
1712
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1704
1713
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1705
1714
 
1706
- | Param | Type |
1707
- | ------ | ----------------------------------------------------------- |
1708
- | params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |
1715
+ | Param | Type |
1716
+ | ------ | ----------------------------------------------------------------------- |
1717
+ | params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |
1709
1718
 
1710
1719
  ### graphQLClient.encodeUpdateTokenFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1711
1720
 
@@ -1718,27 +1727,27 @@ Encode a UpdateTokenFactoryTx transaction for later use
1718
1727
  | ------ | ----------------------------------------------------------------------- |
1719
1728
  | params | [`UpdateTokenFactoryTxInput`](#GraphQLClient.UpdateTokenFactoryTxInput) |
1720
1729
 
1721
- ### graphQLClient.encodeUpgradeNodeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1730
+ ### graphQLClient.encodeMintTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1722
1731
 
1723
- Encode a UpgradeNodeTx transaction for later use
1732
+ Encode a MintTokenTx transaction for later use
1724
1733
 
1725
1734
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1726
1735
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1727
1736
 
1728
- | Param | Type |
1729
- | ------ | --------------------------------------------------------- |
1730
- | params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |
1737
+ | Param | Type |
1738
+ | ------ | ----------------------------------------------------- |
1739
+ | params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |
1731
1740
 
1732
- ### graphQLClient.encodeWithdrawTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1741
+ ### graphQLClient.encodeBurnTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
1733
1742
 
1734
- Encode a WithdrawTokenV2Tx transaction for later use
1743
+ Encode a BurnTokenTx transaction for later use
1735
1744
 
1736
1745
  **Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
1737
1746
  **Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object
1738
1747
 
1739
- | Param | Type |
1740
- | ------ | ----------------------------------------------------------------- |
1741
- | params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |
1748
+ | Param | Type |
1749
+ | ------ | ----------------------------------------------------- |
1750
+ | params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |
1742
1751
 
1743
1752
  ### graphQLClient.getAccountState(params) ⇒ [`Promise.<ResponseGetAccountState>`](#GraphQLClient.ResponseGetAccountState)
1744
1753
 
@@ -2336,7 +2345,7 @@ Structure of GraphQLClient.RequestGetAccountStateInput
2336
2345
  | -------------- | ---------------- |
2337
2346
  | address | `string` |
2338
2347
  | keys | `Array.<string>` |
2339
- | height | `number` |
2348
+ | height | `string` |
2340
2349
  | traceMigration | `boolean` |
2341
2350
 
2342
2351
  ### GraphQLClient.RequestGetAccountTokensInput : `object`
@@ -2367,9 +2376,7 @@ Structure of GraphQLClient.RequestGetBlockInput
2367
2376
  Checkout the following snippet for the format of RequestGetBlockInput:
2368
2377
 
2369
2378
  ```json
2370
- {
2371
- "height": 123
2372
- }
2379
+ {}
2373
2380
  ```
2374
2381
 
2375
2382
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
@@ -2377,7 +2384,7 @@ Checkout the following snippet for the format of RequestGetBlockInput:
2377
2384
 
2378
2385
  | Name | Type |
2379
2386
  | ------ | -------- |
2380
- | height | `number` |
2387
+ | height | `string` |
2381
2388
 
2382
2389
  ### GraphQLClient.RequestGetBlocksInput : `object`
2383
2390
 
@@ -2447,7 +2454,6 @@ Checkout the following snippet for the format of RequestGetRollupBlockInput:
2447
2454
  ```json
2448
2455
  {
2449
2456
  "hash": "abc",
2450
- "height": 123,
2451
2457
  "rollupAddress": "abc"
2452
2458
  }
2453
2459
  ```
@@ -2458,7 +2464,7 @@ Checkout the following snippet for the format of RequestGetRollupBlockInput:
2458
2464
  | Name | Type |
2459
2465
  | ------------- | -------- |
2460
2466
  | hash | `string` |
2461
- | height | `number` |
2467
+ | height | `string` |
2462
2468
  | rollupAddress | `string` |
2463
2469
 
2464
2470
  ### GraphQLClient.RequestGetStateInput : `object`
@@ -2472,7 +2478,7 @@ Structure of GraphQLClient.RequestGetStateInput
2472
2478
  | ------- | ---------------- |
2473
2479
  | address | `string` |
2474
2480
  | keys | `Array.<string>` |
2475
- | height | `number` |
2481
+ | height | `string` |
2476
2482
 
2477
2483
  ### GraphQLClient.RequestGetTokenDistributionInput : `object`
2478
2484
 
@@ -2706,6 +2712,31 @@ Checkout the following snippet for the format of RequestListStakesInput:
2706
2712
  | ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |
2707
2713
  | ...assetFilter | [`AssetFilterInput`](#GraphQLClient.AssetFilterInput) |
2708
2714
 
2715
+ ### GraphQLClient.RequestListTokenFactoriesInput : `object`
2716
+
2717
+ Structure of GraphQLClient.RequestListTokenFactoriesInput
2718
+
2719
+ Checkout the following snippet for the format of RequestListTokenFactoriesInput:
2720
+
2721
+ ```json
2722
+ {
2723
+ "owner": "abc",
2724
+ "reserveAddress": "abc",
2725
+ "tokenAddress": "abc"
2726
+ }
2727
+ ```
2728
+
2729
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
2730
+ **Properties**
2731
+
2732
+ | Name | Type |
2733
+ | -------------- | --------------------------------------------------- |
2734
+ | ...paging | [`PageInput`](#GraphQLClient.PageInput) |
2735
+ | owner | `string` |
2736
+ | reserveAddress | `string` |
2737
+ | tokenAddress | `string` |
2738
+ | ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |
2739
+
2709
2740
  ### GraphQLClient.RequestListTokenFlowsInput : `object`
2710
2741
 
2711
2742
  Structure of GraphQLClient.RequestListTokenFlowsInput
@@ -2716,7 +2747,6 @@ Checkout the following snippet for the format of RequestListTokenFlowsInput:
2716
2747
  {
2717
2748
  "accountAddress": "abc",
2718
2749
  "tokenAddress": "abc",
2719
- "depth": 123,
2720
2750
  "direction": "IN"
2721
2751
  }
2722
2752
  ```
@@ -2781,7 +2811,9 @@ Structure of GraphQLClient.RequestListTransactionsInput
2781
2811
  Checkout the following snippet for the format of RequestListTransactionsInput:
2782
2812
 
2783
2813
  ```json
2784
- {}
2814
+ {
2815
+ "includeData": true
2816
+ }
2785
2817
  ```
2786
2818
 
2787
2819
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
@@ -2803,6 +2835,7 @@ Checkout the following snippet for the format of RequestListTransactionsInput:
2803
2835
  | ...stakeFilter | [`StakeFilterInput`](#GraphQLClient.StakeFilterInput) |
2804
2836
  | ...delegationFilter | [`DelegationFilterInput`](#GraphQLClient.DelegationFilterInput) |
2805
2837
  | ...tokenFactoryFilter | [`TokenFactoryFilterInput`](#GraphQLClient.TokenFactoryFilterInput) |
2838
+ | includeData | `boolean` |
2806
2839
 
2807
2840
  ### GraphQLClient.RequestSearchInput : `object`
2808
2841
 
@@ -3196,10 +3229,10 @@ Structure of GraphQLClient.AssetLimit
3196
3229
  | address | `Array.<string>` |
3197
3230
  | to | `Array.<string>` |
3198
3231
  | txCount | `number` |
3199
- | validUntil | `number` |
3232
+ | validUntil | `string` |
3200
3233
  | ...rate | [`RateLimit`](#GraphQLClient.RateLimit) |
3201
3234
  | txSent | `number` |
3202
- | lastTx | `number` |
3235
+ | lastTx | `string` |
3203
3236
 
3204
3237
  ### GraphQLClient.AssetState : `object`
3205
3238
 
@@ -3293,42 +3326,45 @@ Structure of GraphQLClient.BlockInfoSimple
3293
3326
  | ...version | [`Version`](#GraphQLClient.Version) |
3294
3327
  | ...lastBlockId | [`BlockID`](#GraphQLClient.BlockID) |
3295
3328
 
3296
- ### GraphQLClient.ChainInfo : `object`
3329
+ ### GraphQLClient.BurnTokenTx : `object`
3297
3330
 
3298
- Structure of GraphQLClient.ChainInfo
3331
+ Structure of GraphQLClient.BurnTokenTx
3299
3332
 
3300
3333
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3301
3334
  **Properties**
3302
3335
 
3303
- | Name | Type |
3304
- | ---------------- | ----------------------------------------------------------- |
3305
- | id | `string` |
3306
- | network | `string` |
3307
- | moniker | `string` |
3308
- | consensusVersion | `string` |
3309
- | synced | `boolean` |
3310
- | appHash | `string` |
3311
- | blockHash | `string` |
3312
- | blockHeight | `string` |
3313
- | blockTime | `string` |
3314
- | address | `string` |
3315
- | votingPower | `string` |
3316
- | totalTxs | `string` |
3317
- | version | `string` |
3318
- | forgeAppsVersion | `Array.<...GraphQLClient.ChainInfo\_ForgeAppsVersionEntry>` |
3319
- | supportedTxs | `Array.<string>` |
3336
+ | Name | Type |
3337
+ | ------------ | ------------------------------------------- |
3338
+ | tokenFactory | `string` |
3339
+ | inputs | `Array.<...GraphQLClient.TransactionInput>` |
3340
+ | minReserve | `string` |
3341
+ | receiver | `string` |
3342
+ | ...data | [`Any`](#GraphQLClient.Any) |
3320
3343
 
3321
- ### GraphQLClient.ChainInfo\_ForgeAppsVersionEntry : `object`
3344
+ ### GraphQLClient.ChainInfo : `object`
3322
3345
 
3323
- Structure of GraphQLClient.ChainInfo\_ForgeAppsVersionEntry
3346
+ Structure of GraphQLClient.ChainInfo
3324
3347
 
3325
3348
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3326
3349
  **Properties**
3327
3350
 
3328
- | Name | Type |
3329
- | ----- | -------- |
3330
- | key | `string` |
3331
- | value | `string` |
3351
+ | Name | Type |
3352
+ | ---------------- | ---------------- |
3353
+ | id | `string` |
3354
+ | network | `string` |
3355
+ | moniker | `string` |
3356
+ | consensusVersion | `string` |
3357
+ | synced | `boolean` |
3358
+ | appHash | `string` |
3359
+ | blockHash | `string` |
3360
+ | blockHeight | `string` |
3361
+ | blockTime | `string` |
3362
+ | address | `string` |
3363
+ | votingPower | `string` |
3364
+ | totalTxs | `string` |
3365
+ | version | `string` |
3366
+ | forgeAppsVersion | `object` |
3367
+ | supportedTxs | `Array.<string>` |
3332
3368
 
3333
3369
  ### GraphQLClient.ClaimBlockRewardTx : `object`
3334
3370
 
@@ -3339,7 +3375,6 @@ Checkout the following snippet for the format of ClaimBlockRewardTx:
3339
3375
  ```json
3340
3376
  {
3341
3377
  "rollup": "abc",
3342
- "blockHeight": 123,
3343
3378
  "blockHash": "abc",
3344
3379
  "evidence": {
3345
3380
  "hash": "abc"
@@ -3358,7 +3393,7 @@ Checkout the following snippet for the format of ClaimBlockRewardTx:
3358
3393
  | Name | Type |
3359
3394
  | ----------- | ------------------------------------- |
3360
3395
  | rollup | `string` |
3361
- | blockHeight | `number` |
3396
+ | blockHeight | `string` |
3362
3397
  | blockHash | `string` |
3363
3398
  | ...evidence | [`Evidence`](#GraphQLClient.Evidence) |
3364
3399
  | publisher | `string` |
@@ -3512,7 +3547,7 @@ Structure of GraphQLClient.CreateRollupBlockTx
3512
3547
  | Name | Type |
3513
3548
  | ------------ | ----------------------------------- |
3514
3549
  | hash | `string` |
3515
- | height | `number` |
3550
+ | height | `string` |
3516
3551
  | merkleRoot | `string` |
3517
3552
  | previousHash | `string` |
3518
3553
  | txsHash | `string` |
@@ -3566,6 +3601,22 @@ Structure of GraphQLClient.CreateRollupTx
3566
3601
  | publishSlashRate | `number` |
3567
3602
  | ...data | [`Any`](#GraphQLClient.Any) |
3568
3603
 
3604
+ ### GraphQLClient.CreateTokenFactoryTx : `object`
3605
+
3606
+ Structure of GraphQLClient.CreateTokenFactoryTx
3607
+
3608
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3609
+ **Properties**
3610
+
3611
+ | Name | Type |
3612
+ | -------------- | ------------------------------------------- |
3613
+ | address | `string` |
3614
+ | feeRate | `number` |
3615
+ | ...token | [`TokenInfo`](#GraphQLClient.TokenInfo) |
3616
+ | reserveAddress | `string` |
3617
+ | ...curve | [`CurveConfig`](#GraphQLClient.CurveConfig) |
3618
+ | ...data | [`Any`](#GraphQLClient.Any) |
3619
+
3569
3620
  ### GraphQLClient.CreateTokenTx : `object`
3570
3621
 
3571
3622
  Structure of GraphQLClient.CreateTokenTx
@@ -3587,8 +3638,6 @@ Structure of GraphQLClient.CreateTokenTx
3587
3638
  | maxTotalSupply | `string` |
3588
3639
  | ...foreignToken | [`ForeignToken`](#GraphQLClient.ForeignToken) |
3589
3640
  | spenders | `Array.<string>` |
3590
- | website | `string` |
3591
- | ...metadata | [`Any`](#GraphQLClient.Any) |
3592
3641
  | ...data | [`Any`](#GraphQLClient.Any) |
3593
3642
 
3594
3643
  ### GraphQLClient.CurveConfig : `object`
@@ -3602,10 +3651,36 @@ Structure of GraphQLClient.CurveConfig
3602
3651
  | ---------- | -------- |
3603
3652
  | type | `string` |
3604
3653
  | basePrice | `string` |
3605
- | fixedPrice | `string` |
3606
3654
  | slope | `string` |
3655
+ | fixedPrice | `string` |
3607
3656
  | constant | `number` |
3608
3657
 
3658
+ ### GraphQLClient.DeclareTx : `object`
3659
+
3660
+ Structure of GraphQLClient.DeclareTx
3661
+
3662
+ Checkout the following snippet for the format of DeclareTx:
3663
+
3664
+ ```json
3665
+ {
3666
+ "moniker": "abc",
3667
+ "issuer": "abc",
3668
+ "data": {
3669
+ "typeUrl": "abc",
3670
+ "value": "abc"
3671
+ }
3672
+ }
3673
+ ```
3674
+
3675
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3676
+ **Properties**
3677
+
3678
+ | Name | Type |
3679
+ | ------- | --------------------------- |
3680
+ | moniker | `string` |
3681
+ | issuer | `string` |
3682
+ | ...data | [`Any`](#GraphQLClient.Any) |
3683
+
3609
3684
  ### GraphQLClient.DelegateConfig : `object`
3610
3685
 
3611
3686
  Structure of GraphQLClient.DelegateConfig
@@ -3653,8 +3728,8 @@ Structure of GraphQLClient.DelegateOpState
3653
3728
  | Name | Type |
3654
3729
  | ------------ | ----------------------------------------------- |
3655
3730
  | rule | `string` |
3656
- | numTxs | `number` |
3657
- | numTxsDelta | `number` |
3731
+ | numTxs | `string` |
3732
+ | numTxsDelta | `string` |
3658
3733
  | balance | `string` |
3659
3734
  | balanceDelta | `string` |
3660
3735
  | ...limit | [`DelegateLimit`](#GraphQLClient.DelegateLimit) |
@@ -3666,26 +3741,16 @@ Structure of GraphQLClient.DelegateState
3666
3741
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3667
3742
  **Properties**
3668
3743
 
3669
- | Name | Type |
3670
- | ---------- | -------------------------------------------------- |
3671
- | address | `string` |
3672
- | ops | `Array.<...GraphQLClient.DelegateState\_OpsEntry>` |
3673
- | from | `string` |
3674
- | to | `string` |
3675
- | ...context | [`StateContext`](#GraphQLClient.StateContext) |
3676
- | ...data | [`Any`](#GraphQLClient.Any) |
3677
-
3678
- ### GraphQLClient.DelegateState\_OpsEntry : `object`
3679
-
3680
- Structure of GraphQLClient.DelegateState\_OpsEntry
3681
-
3682
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3683
- **Properties**
3684
-
3685
- | Name | Type |
3686
- | -------- | --------------------------------------------------- |
3687
- | key | `string` |
3688
- | ...value | [`DelegateOpState`](#GraphQLClient.DelegateOpState) |
3744
+ | Name | Type |
3745
+ | ---------- | --------------------------------------------- |
3746
+ | address | `string` |
3747
+ | ops | `object` |
3748
+ | from | `string` |
3749
+ | to | `string` |
3750
+ | deny | `Array.<string>` |
3751
+ | validUntil | `string` |
3752
+ | ...context | [`StateContext`](#GraphQLClient.StateContext) |
3753
+ | ...data | [`Any`](#GraphQLClient.Any) |
3689
3754
 
3690
3755
  ### GraphQLClient.DelegateTx : `object`
3691
3756
 
@@ -3694,12 +3759,14 @@ Structure of GraphQLClient.DelegateTx
3694
3759
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3695
3760
  **Properties**
3696
3761
 
3697
- | Name | Type |
3698
- | ------- | ------------------------------------- |
3699
- | address | `string` |
3700
- | to | `string` |
3701
- | ops | `Array.<...GraphQLClient.DelegateOp>` |
3702
- | ...data | [`Any`](#GraphQLClient.Any) |
3762
+ | Name | Type |
3763
+ | ---------- | ------------------------------------- |
3764
+ | address | `string` |
3765
+ | to | `string` |
3766
+ | ops | `Array.<...GraphQLClient.DelegateOp>` |
3767
+ | deny | `Array.<string>` |
3768
+ | validUntil | `string` |
3769
+ | ...data | [`Any`](#GraphQLClient.Any) |
3703
3770
 
3704
3771
  ### GraphQLClient.DepositTokenV2Tx : `object`
3705
3772
 
@@ -3845,7 +3912,7 @@ Structure of GraphQLClient.ForgeState
3845
3912
  | --------------- | ------------------------------------------------------- |
3846
3913
  | address | `string` |
3847
3914
  | ...consensus | [`ConsensusParams`](#GraphQLClient.ConsensusParams) |
3848
- | tasks | `Array.<...GraphQLClient.ForgeState\_TasksEntry>` |
3915
+ | tasks | `object` |
3849
3916
  | version | `string` |
3850
3917
  | ...token | [`ForgeToken`](#GraphQLClient.ForgeToken) |
3851
3918
  | ...txConfig | [`TransactionConfig`](#GraphQLClient.TransactionConfig) |
@@ -3855,18 +3922,6 @@ Structure of GraphQLClient.ForgeState
3855
3922
  | reservedSymbols | `Array.<string>` |
3856
3923
  | ...data | [`Any`](#GraphQLClient.Any) |
3857
3924
 
3858
- ### GraphQLClient.ForgeState\_TasksEntry : `object`
3859
-
3860
- Structure of GraphQLClient.ForgeState\_TasksEntry
3861
-
3862
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
3863
- **Properties**
3864
-
3865
- | Name | Type |
3866
- | -------- | --------------------------------------------- |
3867
- | key | `number` |
3868
- | ...value | [`UpgradeTasks`](#GraphQLClient.UpgradeTasks) |
3869
-
3870
3925
  ### GraphQLClient.ForgeStats : `object`
3871
3926
 
3872
3927
  Structure of GraphQLClient.ForgeStats
@@ -3964,7 +4019,7 @@ Structure of GraphQLClient.IndexedAccountState
3964
4019
  | totalStakes | `string` |
3965
4020
  | totalUnstakes | `string` |
3966
4021
  | recentNumTxs | `Array.<string>` |
3967
- | tokens | `Array.<...GraphQLClient.TokenInfo>` |
4022
+ | tokens | `Array.<...GraphQLClient.TokenMeta>` |
3968
4023
 
3969
4024
  ### GraphQLClient.IndexedAssetState : `object`
3970
4025
 
@@ -4013,31 +4068,19 @@ Structure of GraphQLClient.IndexedDelegationState
4013
4068
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4014
4069
  **Properties**
4015
4070
 
4016
- | Name | Type |
4017
- | --------------- | ----------------------------------------------------------- |
4018
- | address | `string` |
4019
- | from | `string` |
4020
- | to | `string` |
4021
- | genesisTime | `string` |
4022
- | renaissanceTime | `string` |
4023
- | ops | `Array.<...GraphQLClient.IndexedDelegationState\_OpsEntry>` |
4024
- | ...data | [`Any`](#GraphQLClient.Any) |
4071
+ | Name | Type |
4072
+ | --------------- | --------------------------- |
4073
+ | address | `string` |
4074
+ | from | `string` |
4075
+ | to | `string` |
4076
+ | genesisTime | `string` |
4077
+ | renaissanceTime | `string` |
4078
+ | ops | `object` |
4079
+ | ...data | [`Any`](#GraphQLClient.Any) |
4025
4080
 
4026
- ### GraphQLClient.IndexedDelegationState\_OpsEntry : `object`
4081
+ ### GraphQLClient.IndexedFactoryInput : `object`
4027
4082
 
4028
- Structure of GraphQLClient.IndexedDelegationState\_OpsEntry
4029
-
4030
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4031
- **Properties**
4032
-
4033
- | Name | Type |
4034
- | -------- | --------------------------------------------------- |
4035
- | key | `string` |
4036
- | ...value | [`DelegateOpState`](#GraphQLClient.DelegateOpState) |
4037
-
4038
- ### GraphQLClient.IndexedFactoryInput : `object`
4039
-
4040
- Structure of GraphQLClient.IndexedFactoryInput
4083
+ Structure of GraphQLClient.IndexedFactoryInput
4041
4084
 
4042
4085
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4043
4086
  **Properties**
@@ -4070,7 +4113,7 @@ Structure of GraphQLClient.IndexedFactoryState
4070
4113
  | hooks | `Array.<...GraphQLClient.AssetFactoryHook>` |
4071
4114
  | ...data | [`Any`](#GraphQLClient.Any) |
4072
4115
  | balance | `string` |
4073
- | tokens | `Array.<...GraphQLClient.TokenInfo>` |
4116
+ | tokens | `Array.<...GraphQLClient.TokenMeta>` |
4074
4117
  | numMinted | `number` |
4075
4118
  | lastSettlement | `string` |
4076
4119
  | genesisTime | `string` |
@@ -4087,7 +4130,7 @@ Structure of GraphQLClient.IndexedRollupBlock
4087
4130
  | Name | Type |
4088
4131
  | --------------- | ------------------------------------------------------- |
4089
4132
  | hash | `string` |
4090
- | height | `number` |
4133
+ | height | `string` |
4091
4134
  | merkleRoot | `string` |
4092
4135
  | previousHash | `string` |
4093
4136
  | txsHash | `string` |
@@ -4135,7 +4178,7 @@ Structure of GraphQLClient.IndexedRollupState
4135
4178
  | proposerFeeShare | `number` |
4136
4179
  | minDepositAmount | `string` |
4137
4180
  | minWithdrawAmount | `string` |
4138
- | blockHeight | `number` |
4181
+ | blockHeight | `string` |
4139
4182
  | blockHash | `string` |
4140
4183
  | minBlockConfirmation | `number` |
4141
4184
  | totalDepositAmount | `string` |
@@ -4178,9 +4221,9 @@ Structure of GraphQLClient.IndexedRollupValidator
4178
4221
  | revokedStake | `string` |
4179
4222
  | availableStake | `string` |
4180
4223
  | totalGain | `string` |
4181
- | proposedBlockCount | `number` |
4182
- | verifiedBlockCount | `number` |
4183
- | latestBlockHeight | `number` |
4224
+ | proposedBlockCount | `string` |
4225
+ | verifiedBlockCount | `string` |
4226
+ | latestBlockHeight | `string` |
4184
4227
  | latestBlockHash | `string` |
4185
4228
  | rollup | `string` |
4186
4229
 
@@ -4196,14 +4239,14 @@ Structure of GraphQLClient.IndexedStakeState
4196
4239
  | address | `string` |
4197
4240
  | sender | `string` |
4198
4241
  | receiver | `string` |
4199
- | tokens | `Array.<...GraphQLClient.TokenInfo>` |
4242
+ | tokens | `Array.<...GraphQLClient.TokenMeta>` |
4200
4243
  | assets | `Array.<string>` |
4201
4244
  | revocable | `boolean` |
4202
4245
  | genesisTime | `string` |
4203
4246
  | renaissanceTime | `string` |
4204
4247
  | message | `string` |
4205
4248
  | revokeWaitingPeriod | `number` |
4206
- | revokedTokens | `Array.<...GraphQLClient.TokenInfo>` |
4249
+ | revokedTokens | `Array.<...GraphQLClient.TokenMeta>` |
4207
4250
  | revokedAssets | `Array.<string>` |
4208
4251
  | slashers | `Array.<string>` |
4209
4252
  | nonce | `string` |
@@ -4279,18 +4322,18 @@ Structure of GraphQLClient.IndexedTokenState
4279
4322
  | issuer | `string` |
4280
4323
  | icon | `string` |
4281
4324
  | totalSupply | `string` |
4282
- | initialSupply | `string` |
4283
- | maxTotalSupply | `string` |
4284
4325
  | address | `string` |
4285
4326
  | genesisTime | `string` |
4286
4327
  | renaissanceTime | `string` |
4287
4328
  | ...foreignToken | [`ForeignToken`](#GraphQLClient.ForeignToken) |
4288
4329
  | tokenFactoryAddress | `string` |
4330
+ | maxTotalSupply | `string` |
4331
+ | initialSupply | `string` |
4332
+ | ...metadata | [`Any`](#GraphQLClient.Any) |
4289
4333
  | website | `string` |
4290
4334
  | spenders | `Array.<string>` |
4291
4335
  | minters | `Array.<string>` |
4292
4336
  | type | `string` |
4293
- | ...metadata | [`Any`](#GraphQLClient.Any) |
4294
4337
  | ...data | [`Any`](#GraphQLClient.Any) |
4295
4338
 
4296
4339
  ### GraphQLClient.IndexedTransaction : `object`
@@ -4310,7 +4353,7 @@ Structure of GraphQLClient.IndexedTransaction
4310
4353
  | ...tx | [`Transaction`](#GraphQLClient.Transaction) |
4311
4354
  | valid | `boolean` |
4312
4355
  | code | `string` |
4313
- | tokenSymbols | `Array.<...GraphQLClient.TokenSymbol>` |
4356
+ | tokenSymbols | `Array.<...GraphQLClient.TokenMeta>` |
4314
4357
  | receipts | `Array.<...GraphQLClient.TransactionReceipt>` |
4315
4358
 
4316
4359
  ### GraphQLClient.JoinRollupTx : `object`
@@ -4400,6 +4443,21 @@ Structure of GraphQLClient.MintAssetTx
4400
4443
  | owner | `string` |
4401
4444
  | ...data | [`Any`](#GraphQLClient.Any) |
4402
4445
 
4446
+ ### GraphQLClient.MintTokenTx : `object`
4447
+
4448
+ Structure of GraphQLClient.MintTokenTx
4449
+
4450
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4451
+ **Properties**
4452
+
4453
+ | Name | Type |
4454
+ | ------------ | ------------------------------------------- |
4455
+ | tokenFactory | `string` |
4456
+ | amount | `string` |
4457
+ | inputs | `Array.<...GraphQLClient.TransactionInput>` |
4458
+ | receiver | `string` |
4459
+ | ...data | [`Any`](#GraphQLClient.Any) |
4460
+
4403
4461
  ### GraphQLClient.Multisig : `object`
4404
4462
 
4405
4463
  Structure of GraphQLClient.Multisig
@@ -4473,38 +4531,26 @@ Structure of GraphQLClient.NodeInfo
4473
4531
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4474
4532
  **Properties**
4475
4533
 
4476
- | Name | Type |
4477
- | ---------------- | ---------------------------------------------------------- |
4478
- | id | `string` |
4479
- | network | `string` |
4480
- | moniker | `string` |
4481
- | consensusVersion | `string` |
4482
- | synced | `boolean` |
4483
- | appHash | `string` |
4484
- | blockHash | `string` |
4485
- | blockHeight | `string` |
4486
- | blockTime | `string` |
4487
- | address | `string` |
4488
- | votingPower | `string` |
4489
- | totalTxs | `string` |
4490
- | version | `string` |
4491
- | forgeAppsVersion | `Array.<...GraphQLClient.NodeInfo\_ForgeAppsVersionEntry>` |
4492
- | supportedTxs | `Array.<string>` |
4493
- | ip | `string` |
4494
- | ...geoInfo | [`GeoInfo`](#GraphQLClient.GeoInfo) |
4495
- | p2pAddress | `string` |
4496
-
4497
- ### GraphQLClient.NodeInfo\_ForgeAppsVersionEntry : `object`
4498
-
4499
- Structure of GraphQLClient.NodeInfo\_ForgeAppsVersionEntry
4500
-
4501
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
4502
- **Properties**
4503
-
4504
- | Name | Type |
4505
- | ----- | -------- |
4506
- | key | `string` |
4507
- | value | `string` |
4534
+ | Name | Type |
4535
+ | ---------------- | ----------------------------------- |
4536
+ | id | `string` |
4537
+ | network | `string` |
4538
+ | moniker | `string` |
4539
+ | consensusVersion | `string` |
4540
+ | synced | `boolean` |
4541
+ | appHash | `string` |
4542
+ | blockHash | `string` |
4543
+ | blockHeight | `string` |
4544
+ | blockTime | `string` |
4545
+ | address | `string` |
4546
+ | votingPower | `string` |
4547
+ | totalTxs | `string` |
4548
+ | version | `string` |
4549
+ | forgeAppsVersion | `object` |
4550
+ | supportedTxs | `Array.<string>` |
4551
+ | ip | `string` |
4552
+ | ...geoInfo | [`GeoInfo`](#GraphQLClient.GeoInfo) |
4553
+ | p2pAddress | `string` |
4508
4554
 
4509
4555
  ### GraphQLClient.PageInfo : `object`
4510
4556
 
@@ -4592,8 +4638,8 @@ Structure of GraphQLClient.RateLimit
4592
4638
 
4593
4639
  | Name | Type |
4594
4640
  | -------- | -------- |
4595
- | interval | `number` |
4596
- | anchor | `number` |
4641
+ | interval | `string` |
4642
+ | anchor | `string` |
4597
4643
 
4598
4644
  ### GraphQLClient.ReceiptChange : `object`
4599
4645
 
@@ -5169,9 +5215,7 @@ Checkout the following snippet for the format of ResponseVerifyAccountRisk:
5169
5215
  "address": "abc",
5170
5216
  "balance": "abc",
5171
5217
  "transferIn": "abc",
5172
- "transferOut": "abc",
5173
- "accountCount": 123,
5174
- "txCount": 123
5218
+ "transferOut": "abc"
5175
5219
  }
5176
5220
  }
5177
5221
  }
@@ -5260,7 +5304,7 @@ Structure of GraphQLClient.RollupBlock
5260
5304
  | Name | Type |
5261
5305
  | ------------ | --------------------------------------------- |
5262
5306
  | hash | `string` |
5263
- | height | `number` |
5307
+ | height | `string` |
5264
5308
  | merkleRoot | `string` |
5265
5309
  | previousHash | `string` |
5266
5310
  | txsHash | `string` |
@@ -5306,7 +5350,7 @@ Structure of GraphQLClient.RollupState
5306
5350
  | publisherFeeShare | `number` |
5307
5351
  | minDepositAmount | `string` |
5308
5352
  | minWithdrawAmount | `string` |
5309
- | blockHeight | `number` |
5353
+ | blockHeight | `string` |
5310
5354
  | blockHash | `string` |
5311
5355
  | ...tokenInfo | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
5312
5356
  | totalDepositAmount | `string` |
@@ -5348,11 +5392,15 @@ Structure of GraphQLClient.SearchResult
5348
5392
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
5349
5393
  **Properties**
5350
5394
 
5351
- | Name | Type |
5352
- | ----- | -------- |
5353
- | type | `string` |
5354
- | id | `string` |
5355
- | title | `string` |
5395
+ | Name | Type |
5396
+ | ----------- | ---------------- |
5397
+ | type | `string` |
5398
+ | id | `string` |
5399
+ | title | `string` |
5400
+ | subtitle | `string` |
5401
+ | description | `string` |
5402
+ | tags | `Array.<string>` |
5403
+ | timestamp | `string` |
5356
5404
 
5357
5405
  ### GraphQLClient.SlashStakeTx : `object`
5358
5406
 
@@ -5454,16 +5502,17 @@ Structure of GraphQLClient.TokenFactoryState
5454
5502
  | Name | Type |
5455
5503
  | --------------- | --------------------------------------------- |
5456
5504
  | address | `string` |
5505
+ | owner | `string` |
5457
5506
  | tokenAddress | `string` |
5458
5507
  | reserveAddress | `string` |
5508
+ | ...curve | [`CurveConfig`](#GraphQLClient.CurveConfig) |
5459
5509
  | currentSupply | `string` |
5460
5510
  | reserveBalance | `string` |
5461
- | owner | `string` |
5462
5511
  | feeRate | `number` |
5463
- | ...curve | [`CurveConfig`](#GraphQLClient.CurveConfig) |
5464
- | ...context | [`StateContext`](#GraphQLClient.StateContext) |
5512
+ | status | `string` |
5465
5513
  | ...token | [`TokenState`](#GraphQLClient.TokenState) |
5466
5514
  | ...reserveToken | [`TokenState`](#GraphQLClient.TokenState) |
5515
+ | ...context | [`StateContext`](#GraphQLClient.StateContext) |
5467
5516
  | ...data | [`Any`](#GraphQLClient.Any) |
5468
5517
 
5469
5518
  ### GraphQLClient.TokenInfo : `object`
@@ -5473,13 +5522,21 @@ Structure of GraphQLClient.TokenInfo
5473
5522
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
5474
5523
  **Properties**
5475
5524
 
5476
- | Name | Type |
5477
- | ------- | -------- |
5478
- | address | `string` |
5479
- | balance | `string` |
5480
- | decimal | `number` |
5481
- | unit | `string` |
5482
- | symbol | `string` |
5525
+ | Name | Type |
5526
+ | -------------- | --------------------------- |
5527
+ | address | `string` |
5528
+ | symbol | `string` |
5529
+ | decimal | `number` |
5530
+ | unit | `string` |
5531
+ | name | `string` |
5532
+ | description | `string` |
5533
+ | icon | `string` |
5534
+ | maxTotalSupply | `string` |
5535
+ | ...metadata | [`Any`](#GraphQLClient.Any) |
5536
+ | website | `string` |
5537
+ | spenders | `Array.<string>` |
5538
+ | minters | `Array.<string>` |
5539
+ | type | `string` |
5483
5540
 
5484
5541
  ### GraphQLClient.TokenInput : `object`
5485
5542
 
@@ -5507,14 +5564,29 @@ Structure of GraphQLClient.TokenLimit
5507
5564
  | txCount | `number` |
5508
5565
  | txAllowance | `string` |
5509
5566
  | totalAllowance | `string` |
5510
- | validUntil | `number` |
5567
+ | validUntil | `string` |
5511
5568
  | ...rate | [`RateLimit`](#GraphQLClient.RateLimit) |
5512
5569
  | txSent | `number` |
5513
5570
  | spentAllowance | `string` |
5514
- | lastTx | `number` |
5571
+ | lastTx | `string` |
5515
5572
  | decimal | `number` |
5516
5573
  | symbol | `string` |
5517
5574
 
5575
+ ### GraphQLClient.TokenMeta : `object`
5576
+
5577
+ Structure of GraphQLClient.TokenMeta
5578
+
5579
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
5580
+ **Properties**
5581
+
5582
+ | Name | Type |
5583
+ | ------- | -------- |
5584
+ | address | `string` |
5585
+ | balance | `string` |
5586
+ | decimal | `number` |
5587
+ | unit | `string` |
5588
+ | symbol | `string` |
5589
+
5518
5590
  ### GraphQLClient.TokenState : `object`
5519
5591
 
5520
5592
  Structure of GraphQLClient.TokenState
@@ -5533,16 +5605,16 @@ Structure of GraphQLClient.TokenState
5533
5605
  | decimal | `number` |
5534
5606
  | icon | `string` |
5535
5607
  | totalSupply | `string` |
5536
- | initialSupply | `string` |
5537
- | maxTotalSupply | `string` |
5538
5608
  | ...foreignToken | [`ForeignToken`](#GraphQLClient.ForeignToken) |
5539
5609
  | tokenFactoryAddress | `string` |
5610
+ | initialSupply | `string` |
5611
+ | maxTotalSupply | `string` |
5612
+ | ...metadata | [`Any`](#GraphQLClient.Any) |
5613
+ | ...context | [`StateContext`](#GraphQLClient.StateContext) |
5540
5614
  | website | `string` |
5541
5615
  | spenders | `Array.<string>` |
5542
5616
  | minters | `Array.<string>` |
5543
5617
  | type | `string` |
5544
- | ...metadata | [`Any`](#GraphQLClient.Any) |
5545
- | ...context | [`StateContext`](#GraphQLClient.StateContext) |
5546
5618
  | ...data | [`Any`](#GraphQLClient.Any) |
5547
5619
 
5548
5620
  ### GraphQLClient.TokenSymbol : `object`
@@ -5575,7 +5647,7 @@ Structure of GraphQLClient.Transaction
5575
5647
  | pk | `string` |
5576
5648
  | signature | `string` |
5577
5649
  | signatures | `Array.<...GraphQLClient.Multisig>` |
5578
- | itxJson | `undefined` |
5650
+ | itxJson | `object` |
5579
5651
  | sender | `string` |
5580
5652
  | receiver | `string` |
5581
5653
  | serviceFee | `string` |
@@ -5708,13 +5780,13 @@ Structure of GraphQLClient.TxGasConfig
5708
5780
 
5709
5781
  | Name | Type |
5710
5782
  | --------------- | -------- |
5711
- | price | `number` |
5712
- | createState | `number` |
5713
- | updateState | `number` |
5714
- | dataStorage | `number` |
5783
+ | price | `string` |
5784
+ | createState | `string` |
5785
+ | updateState | `string` |
5786
+ | dataStorage | `string` |
5715
5787
  | minStake | `string` |
5716
5788
  | maxStake | `string` |
5717
- | stakeLockPeriod | `number` |
5789
+ | stakeLockPeriod | `string` |
5718
5790
 
5719
5791
  ### GraphQLClient.TxStakeConfig : `object`
5720
5792
 
@@ -5726,8 +5798,7 @@ Structure of GraphQLClient.TxStakeConfig
5726
5798
  | Name | Type |
5727
5799
  | --------------------- | -------- |
5728
5800
  | createToken | `string` |
5729
- | createCreditToken | `string` |
5730
- | createTokenLockPeriod | `number` |
5801
+ | createTokenLockPeriod | `string` |
5731
5802
 
5732
5803
  ### GraphQLClient.UnconfirmedTxs : `object`
5733
5804
 
@@ -5779,15 +5850,6 @@ Checkout the following snippet for the format of UpdateRollupTx:
5779
5850
  {
5780
5851
  "minStakeAmount": "abc",
5781
5852
  "maxStakeAmount": "abc",
5782
- "minSignerCount": 123,
5783
- "maxSignerCount": 123,
5784
- "minBlockSize": 123,
5785
- "maxBlockSize": 123,
5786
- "minBlockInterval": 123,
5787
- "minBlockConfirmation": 123,
5788
- "depositFeeRate": 123,
5789
- "withdrawFeeRate": 123,
5790
- "proposerFeeShare": 123,
5791
5853
  "minDepositAmount": "abc",
5792
5854
  "minWithdrawAmount": "abc",
5793
5855
  "maxDepositAmount": "abc",
@@ -5796,10 +5858,6 @@ Checkout the following snippet for the format of UpdateRollupTx:
5796
5858
  "maxDepositFee": "abc",
5797
5859
  "minWithdrawFee": "abc",
5798
5860
  "maxWithdrawFee": "abc",
5799
- "publisherFeeShare": 123,
5800
- "leaveWaitingPeriod": 123,
5801
- "publishWaitingPeriod": 123,
5802
- "publishSlashRate": 123,
5803
5861
  "rollup": "abc",
5804
5862
  "data": {
5805
5863
  "typeUrl": "abc",
@@ -5839,6 +5897,20 @@ Checkout the following snippet for the format of UpdateRollupTx:
5839
5897
  | rollup | `string` |
5840
5898
  | ...data | [`Any`](#GraphQLClient.Any) |
5841
5899
 
5900
+ ### GraphQLClient.UpdateTokenFactoryTx : `object`
5901
+
5902
+ Structure of GraphQLClient.UpdateTokenFactoryTx
5903
+
5904
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
5905
+ **Properties**
5906
+
5907
+ | Name | Type |
5908
+ | -------- | --------------------------------------- |
5909
+ | address | `string` |
5910
+ | feeRate | `number` |
5911
+ | ...token | [`TokenInfo`](#GraphQLClient.TokenInfo) |
5912
+ | ...data | [`Any`](#GraphQLClient.Any) |
5913
+
5842
5914
  ### GraphQLClient.UpgradeInfo : `object`
5843
5915
 
5844
5916
  Structure of GraphQLClient.UpgradeInfo
@@ -5859,7 +5931,6 @@ Checkout the following snippet for the format of UpgradeNodeTx:
5859
5931
 
5860
5932
  ```json
5861
5933
  {
5862
- "height": 123,
5863
5934
  "version": "abc",
5864
5935
  "override": true
5865
5936
  }
@@ -5870,7 +5941,7 @@ Checkout the following snippet for the format of UpgradeNodeTx:
5870
5941
 
5871
5942
  | Name | Type |
5872
5943
  | -------- | --------- |
5873
- | height | `number` |
5944
+ | height | `string` |
5874
5945
  | version | `string` |
5875
5946
  | override | `boolean` |
5876
5947
 
@@ -6003,8 +6074,8 @@ Structure of GraphQLClient.Version
6003
6074
 
6004
6075
  | Name | Type |
6005
6076
  | ----- | -------- |
6006
- | block | `number` |
6007
- | app | `number` |
6077
+ | block | `string` |
6078
+ | app | `string` |
6008
6079
 
6009
6080
  ### GraphQLClient.WalletType : `object`
6010
6081
 
@@ -6882,26 +6953,26 @@ Checkout the following snippet for the format of SendTxParams:
6882
6953
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6883
6954
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6884
6955
 
6885
- ### GraphQLClient.AcquireAssetV2TxInput : `Object`
6956
+ ### GraphQLClient.DelegateTxInput : `Object`
6886
6957
 
6887
6958
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6888
6959
  **Properties**
6889
6960
 
6890
- | Name | Type | Description |
6891
- | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
6892
- | input | `object` | |
6893
- | input.tx | `object` | data of the transaction |
6894
- | input.tx.itx | [`AcquireAssetV2Tx`](#GraphQLClient.AcquireAssetV2Tx) | the actual transaction object |
6895
- | [input.tx.pk] | `string` | the sender pk |
6896
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6897
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
6898
- | [input.tx.chainId] | `string` | the chainId |
6899
- | [input.tx.signature] | `string` | transaction signature |
6900
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
6901
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6902
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6961
+ | Name | Type | Description |
6962
+ | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
6963
+ | input | `object` | |
6964
+ | input.tx | `object` | data of the transaction |
6965
+ | input.tx.itx | [`DelegateTx`](#GraphQLClient.DelegateTx) | the actual transaction object |
6966
+ | [input.tx.pk] | `string` | the sender pk |
6967
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6968
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
6969
+ | [input.tx.chainId] | `string` | the chainId |
6970
+ | [input.tx.signature] | `string` | transaction signature |
6971
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
6972
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6973
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6903
6974
 
6904
- ### GraphQLClient.AcquireAssetV3TxInput : `Object`
6975
+ ### GraphQLClient.RevokeDelegateTxInput : `Object`
6905
6976
 
6906
6977
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6907
6978
  **Properties**
@@ -6910,7 +6981,7 @@ Checkout the following snippet for the format of SendTxParams:
6910
6981
  | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
6911
6982
  | input | `object` | |
6912
6983
  | input.tx | `object` | data of the transaction |
6913
- | input.tx.itx | [`AcquireAssetV3Tx`](#GraphQLClient.AcquireAssetV3Tx) | the actual transaction object |
6984
+ | input.tx.itx | [`RevokeDelegateTx`](#GraphQLClient.RevokeDelegateTx) | the actual transaction object |
6914
6985
  | [input.tx.pk] | `string` | the sender pk |
6915
6986
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6916
6987
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -6920,45 +6991,45 @@ Checkout the following snippet for the format of SendTxParams:
6920
6991
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6921
6992
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6922
6993
 
6923
- ### GraphQLClient.BurnTokenTxInput : `Object`
6994
+ ### GraphQLClient.UpgradeNodeTxInput : `Object`
6924
6995
 
6925
6996
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6926
6997
  **Properties**
6927
6998
 
6928
- | Name | Type | Description |
6929
- | --------------------- | --------------------------- | --------------------------------------------------------------------------------------------- |
6930
- | input | `object` | |
6931
- | input.tx | `object` | data of the transaction |
6932
- | input.tx.itx | `GraphQLClient.BurnTokenTx` | the actual transaction object |
6933
- | [input.tx.pk] | `string` | the sender pk |
6934
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6935
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
6936
- | [input.tx.chainId] | `string` | the chainId |
6937
- | [input.tx.signature] | `string` | transaction signature |
6938
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
6939
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6940
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6999
+ | Name | Type | Description |
7000
+ | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7001
+ | input | `object` | |
7002
+ | input.tx | `object` | data of the transaction |
7003
+ | input.tx.itx | [`UpgradeNodeTx`](#GraphQLClient.UpgradeNodeTx) | the actual transaction object |
7004
+ | [input.tx.pk] | `string` | the sender pk |
7005
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7006
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7007
+ | [input.tx.chainId] | `string` | the chainId |
7008
+ | [input.tx.signature] | `string` | transaction signature |
7009
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7010
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7011
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6941
7012
 
6942
- ### GraphQLClient.ClaimBlockRewardTxInput : `Object`
7013
+ ### GraphQLClient.ExchangeTxInput : `Object`
6943
7014
 
6944
7015
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6945
7016
  **Properties**
6946
7017
 
6947
- | Name | Type | Description |
6948
- | --------------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
6949
- | input | `object` | |
6950
- | input.tx | `object` | data of the transaction |
6951
- | input.tx.itx | [`ClaimBlockRewardTx`](#GraphQLClient.ClaimBlockRewardTx) | the actual transaction object |
6952
- | [input.tx.pk] | `string` | the sender pk |
6953
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6954
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
6955
- | [input.tx.chainId] | `string` | the chainId |
6956
- | [input.tx.signature] | `string` | transaction signature |
6957
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
6958
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6959
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7018
+ | Name | Type | Description |
7019
+ | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
7020
+ | input | `object` | |
7021
+ | input.tx | `object` | data of the transaction |
7022
+ | input.tx.itx | [`ExchangeTx`](#GraphQLClient.ExchangeTx) | the actual transaction object |
7023
+ | [input.tx.pk] | `string` | the sender pk |
7024
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7025
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7026
+ | [input.tx.chainId] | `string` | the chainId |
7027
+ | [input.tx.signature] | `string` | transaction signature |
7028
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7029
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7030
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6960
7031
 
6961
- ### GraphQLClient.ClaimStakeTxInput : `Object`
7032
+ ### GraphQLClient.ExchangeV2TxInput : `Object`
6962
7033
 
6963
7034
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6964
7035
  **Properties**
@@ -6967,7 +7038,7 @@ Checkout the following snippet for the format of SendTxParams:
6967
7038
  | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
6968
7039
  | input | `object` | |
6969
7040
  | input.tx | `object` | data of the transaction |
6970
- | input.tx.itx | [`ClaimStakeTx`](#GraphQLClient.ClaimStakeTx) | the actual transaction object |
7041
+ | input.tx.itx | [`ExchangeV2Tx`](#GraphQLClient.ExchangeV2Tx) | the actual transaction object |
6971
7042
  | [input.tx.pk] | `string` | the sender pk |
6972
7043
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6973
7044
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -6977,45 +7048,64 @@ Checkout the following snippet for the format of SendTxParams:
6977
7048
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6978
7049
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6979
7050
 
6980
- ### GraphQLClient.CloseRollupTxInput : `Object`
7051
+ ### GraphQLClient.TransferTxInput : `Object`
6981
7052
 
6982
7053
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
6983
7054
  **Properties**
6984
7055
 
6985
- | Name | Type | Description |
6986
- | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
6987
- | input | `object` | |
6988
- | input.tx | `object` | data of the transaction |
6989
- | input.tx.itx | [`CloseRollupTx`](#GraphQLClient.CloseRollupTx) | the actual transaction object |
6990
- | [input.tx.pk] | `string` | the sender pk |
6991
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
6992
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
6993
- | [input.tx.chainId] | `string` | the chainId |
6994
- | [input.tx.signature] | `string` | transaction signature |
6995
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
6996
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
6997
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7056
+ | Name | Type | Description |
7057
+ | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
7058
+ | input | `object` | |
7059
+ | input.tx | `object` | data of the transaction |
7060
+ | input.tx.itx | [`TransferTx`](#GraphQLClient.TransferTx) | the actual transaction object |
7061
+ | [input.tx.pk] | `string` | the sender pk |
7062
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7063
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7064
+ | [input.tx.chainId] | `string` | the chainId |
7065
+ | [input.tx.signature] | `string` | transaction signature |
7066
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7067
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7068
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
6998
7069
 
6999
- ### GraphQLClient.ConsumeAssetTxInput : `Object`
7070
+ ### GraphQLClient.TransferV2TxInput : `Object`
7000
7071
 
7001
7072
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7002
7073
  **Properties**
7003
7074
 
7004
- | Name | Type | Description |
7005
- | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7006
- | input | `object` | |
7007
- | input.tx | `object` | data of the transaction |
7008
- | input.tx.itx | [`ConsumeAssetTx`](#GraphQLClient.ConsumeAssetTx) | the actual transaction object |
7009
- | [input.tx.pk] | `string` | the sender pk |
7010
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7011
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7012
- | [input.tx.chainId] | `string` | the chainId |
7013
- | [input.tx.signature] | `string` | transaction signature |
7014
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7015
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7016
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7075
+ | Name | Type | Description |
7076
+ | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7077
+ | input | `object` | |
7078
+ | input.tx | `object` | data of the transaction |
7079
+ | input.tx.itx | [`TransferV2Tx`](#GraphQLClient.TransferV2Tx) | the actual transaction object |
7080
+ | [input.tx.pk] | `string` | the sender pk |
7081
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7082
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7083
+ | [input.tx.chainId] | `string` | the chainId |
7084
+ | [input.tx.signature] | `string` | transaction signature |
7085
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7086
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7087
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7017
7088
 
7018
- ### GraphQLClient.CreateAssetTxInput : `Object`
7089
+ ### GraphQLClient.TransferV3TxInput : `Object`
7090
+
7091
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7092
+ **Properties**
7093
+
7094
+ | Name | Type | Description |
7095
+ | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7096
+ | input | `object` | |
7097
+ | input.tx | `object` | data of the transaction |
7098
+ | input.tx.itx | [`TransferV3Tx`](#GraphQLClient.TransferV3Tx) | the actual transaction object |
7099
+ | [input.tx.pk] | `string` | the sender pk |
7100
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7101
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7102
+ | [input.tx.chainId] | `string` | the chainId |
7103
+ | [input.tx.signature] | `string` | transaction signature |
7104
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7105
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7106
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7107
+
7108
+ ### GraphQLClient.CreateTokenTxInput : `Object`
7019
7109
 
7020
7110
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7021
7111
  **Properties**
@@ -7024,7 +7114,7 @@ Checkout the following snippet for the format of SendTxParams:
7024
7114
  | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7025
7115
  | input | `object` | |
7026
7116
  | input.tx | `object` | data of the transaction |
7027
- | input.tx.itx | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx) | the actual transaction object |
7117
+ | input.tx.itx | [`CreateTokenTx`](#GraphQLClient.CreateTokenTx) | the actual transaction object |
7028
7118
  | [input.tx.pk] | `string` | the sender pk |
7029
7119
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7030
7120
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7034,121 +7124,7 @@ Checkout the following snippet for the format of SendTxParams:
7034
7124
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7035
7125
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7036
7126
 
7037
- ### GraphQLClient.CreateFactoryTxInput : `Object`
7038
-
7039
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7040
- **Properties**
7041
-
7042
- | Name | Type | Description |
7043
- | --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7044
- | input | `object` | |
7045
- | input.tx | `object` | data of the transaction |
7046
- | input.tx.itx | [`CreateFactoryTx`](#GraphQLClient.CreateFactoryTx) | the actual transaction object |
7047
- | [input.tx.pk] | `string` | the sender pk |
7048
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7049
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7050
- | [input.tx.chainId] | `string` | the chainId |
7051
- | [input.tx.signature] | `string` | transaction signature |
7052
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7053
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7054
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7055
-
7056
- ### GraphQLClient.CreateRollupBlockTxInput : `Object`
7057
-
7058
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7059
- **Properties**
7060
-
7061
- | Name | Type | Description |
7062
- | --------------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7063
- | input | `object` | |
7064
- | input.tx | `object` | data of the transaction |
7065
- | input.tx.itx | [`CreateRollupBlockTx`](#GraphQLClient.CreateRollupBlockTx) | the actual transaction object |
7066
- | [input.tx.pk] | `string` | the sender pk |
7067
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7068
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7069
- | [input.tx.chainId] | `string` | the chainId |
7070
- | [input.tx.signature] | `string` | transaction signature |
7071
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7072
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7073
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7074
-
7075
- ### GraphQLClient.CreateRollupTxInput : `Object`
7076
-
7077
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7078
- **Properties**
7079
-
7080
- | Name | Type | Description |
7081
- | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7082
- | input | `object` | |
7083
- | input.tx | `object` | data of the transaction |
7084
- | input.tx.itx | [`CreateRollupTx`](#GraphQLClient.CreateRollupTx) | the actual transaction object |
7085
- | [input.tx.pk] | `string` | the sender pk |
7086
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7087
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7088
- | [input.tx.chainId] | `string` | the chainId |
7089
- | [input.tx.signature] | `string` | transaction signature |
7090
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7091
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7092
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7093
-
7094
- ### GraphQLClient.CreateTokenFactoryTxInput : `Object`
7095
-
7096
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7097
- **Properties**
7098
-
7099
- | Name | Type | Description |
7100
- | --------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------- |
7101
- | input | `object` | |
7102
- | input.tx | `object` | data of the transaction |
7103
- | input.tx.itx | `GraphQLClient.CreateTokenFactoryTx` | the actual transaction object |
7104
- | [input.tx.pk] | `string` | the sender pk |
7105
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7106
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7107
- | [input.tx.chainId] | `string` | the chainId |
7108
- | [input.tx.signature] | `string` | transaction signature |
7109
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7110
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7111
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7112
-
7113
- ### GraphQLClient.CreateTokenTxInput : `Object`
7114
-
7115
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7116
- **Properties**
7117
-
7118
- | Name | Type | Description |
7119
- | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7120
- | input | `object` | |
7121
- | input.tx | `object` | data of the transaction |
7122
- | input.tx.itx | [`CreateTokenTx`](#GraphQLClient.CreateTokenTx) | the actual transaction object |
7123
- | [input.tx.pk] | `string` | the sender pk |
7124
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7125
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7126
- | [input.tx.chainId] | `string` | the chainId |
7127
- | [input.tx.signature] | `string` | transaction signature |
7128
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7129
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7130
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7131
-
7132
- ### GraphQLClient.DelegateTxInput : `Object`
7133
-
7134
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7135
- **Properties**
7136
-
7137
- | Name | Type | Description |
7138
- | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
7139
- | input | `object` | |
7140
- | input.tx | `object` | data of the transaction |
7141
- | input.tx.itx | [`DelegateTx`](#GraphQLClient.DelegateTx) | the actual transaction object |
7142
- | [input.tx.pk] | `string` | the sender pk |
7143
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7144
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7145
- | [input.tx.chainId] | `string` | the chainId |
7146
- | [input.tx.signature] | `string` | transaction signature |
7147
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7148
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7149
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7150
-
7151
- ### GraphQLClient.DepositTokenV2TxInput : `Object`
7127
+ ### GraphQLClient.AcquireAssetV2TxInput : `Object`
7152
7128
 
7153
7129
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7154
7130
  **Properties**
@@ -7157,7 +7133,7 @@ Checkout the following snippet for the format of SendTxParams:
7157
7133
  | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7158
7134
  | input | `object` | |
7159
7135
  | input.tx | `object` | data of the transaction |
7160
- | input.tx.itx | [`DepositTokenV2Tx`](#GraphQLClient.DepositTokenV2Tx) | the actual transaction object |
7136
+ | input.tx.itx | [`AcquireAssetV2Tx`](#GraphQLClient.AcquireAssetV2Tx) | the actual transaction object |
7161
7137
  | [input.tx.pk] | `string` | the sender pk |
7162
7138
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7163
7139
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7167,100 +7143,24 @@ Checkout the following snippet for the format of SendTxParams:
7167
7143
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7168
7144
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7169
7145
 
7170
- ### GraphQLClient.ExchangeTxInput : `Object`
7171
-
7172
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7173
- **Properties**
7174
-
7175
- | Name | Type | Description |
7176
- | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
7177
- | input | `object` | |
7178
- | input.tx | `object` | data of the transaction |
7179
- | input.tx.itx | [`ExchangeTx`](#GraphQLClient.ExchangeTx) | the actual transaction object |
7180
- | [input.tx.pk] | `string` | the sender pk |
7181
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7182
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7183
- | [input.tx.chainId] | `string` | the chainId |
7184
- | [input.tx.signature] | `string` | transaction signature |
7185
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7186
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7187
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7188
-
7189
- ### GraphQLClient.ExchangeV2TxInput : `Object`
7190
-
7191
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7192
- **Properties**
7193
-
7194
- | Name | Type | Description |
7195
- | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7196
- | input | `object` | |
7197
- | input.tx | `object` | data of the transaction |
7198
- | input.tx.itx | [`ExchangeV2Tx`](#GraphQLClient.ExchangeV2Tx) | the actual transaction object |
7199
- | [input.tx.pk] | `string` | the sender pk |
7200
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7201
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7202
- | [input.tx.chainId] | `string` | the chainId |
7203
- | [input.tx.signature] | `string` | transaction signature |
7204
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7205
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7206
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7207
-
7208
- ### GraphQLClient.JoinRollupTxInput : `Object`
7209
-
7210
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7211
- **Properties**
7212
-
7213
- | Name | Type | Description |
7214
- | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7215
- | input | `object` | |
7216
- | input.tx | `object` | data of the transaction |
7217
- | input.tx.itx | [`JoinRollupTx`](#GraphQLClient.JoinRollupTx) | the actual transaction object |
7218
- | [input.tx.pk] | `string` | the sender pk |
7219
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7220
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7221
- | [input.tx.chainId] | `string` | the chainId |
7222
- | [input.tx.signature] | `string` | transaction signature |
7223
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7224
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7225
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7226
-
7227
- ### GraphQLClient.LeaveRollupTxInput : `Object`
7228
-
7229
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7230
- **Properties**
7231
-
7232
- | Name | Type | Description |
7233
- | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7234
- | input | `object` | |
7235
- | input.tx | `object` | data of the transaction |
7236
- | input.tx.itx | [`LeaveRollupTx`](#GraphQLClient.LeaveRollupTx) | the actual transaction object |
7237
- | [input.tx.pk] | `string` | the sender pk |
7238
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7239
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7240
- | [input.tx.chainId] | `string` | the chainId |
7241
- | [input.tx.signature] | `string` | transaction signature |
7242
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7243
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7244
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7245
-
7246
- ### GraphQLClient.MigrateRollupTxInput : `Object`
7146
+ ### GraphQLClient.AcquireAssetV3TxInput : `Object`
7247
7147
 
7248
7148
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7249
7149
  **Properties**
7250
7150
 
7251
- | Name | Type | Description |
7252
- | --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7253
- | input | `object` | |
7254
- | input.tx | `object` | data of the transaction |
7255
- | input.tx.itx | [`MigrateRollupTx`](#GraphQLClient.MigrateRollupTx) | the actual transaction object |
7256
- | [input.tx.pk] | `string` | the sender pk |
7257
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7258
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7259
- | [input.tx.chainId] | `string` | the chainId |
7260
- | [input.tx.signature] | `string` | transaction signature |
7261
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7262
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7263
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7151
+ | Name | Type | Description |
7152
+ | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7153
+ | input | `object` | |
7154
+ | input.tx | `object` | data of the transaction |
7155
+ | input.tx.itx | [`AcquireAssetV3Tx`](#GraphQLClient.AcquireAssetV3Tx) | the actual transaction object |
7156
+ | [input.tx.pk] | `string` | the sender pk |
7157
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7158
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7159
+ | [input.tx.chainId] | `string` | the chainId |
7160
+ | [input.tx.signature] | `string` | transaction signature |
7161
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7162
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7163
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7264
7164
 
7265
7165
  ### GraphQLClient.MintAssetTxInput : `Object`
7266
7166
 
@@ -7281,26 +7181,26 @@ Checkout the following snippet for the format of SendTxParams:
7281
7181
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7282
7182
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7283
7183
 
7284
- ### GraphQLClient.MintTokenTxInput : `Object`
7184
+ ### GraphQLClient.CreateAssetTxInput : `Object`
7285
7185
 
7286
7186
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7287
7187
  **Properties**
7288
7188
 
7289
- | Name | Type | Description |
7290
- | --------------------- | --------------------------- | --------------------------------------------------------------------------------------------- |
7291
- | input | `object` | |
7292
- | input.tx | `object` | data of the transaction |
7293
- | input.tx.itx | `GraphQLClient.MintTokenTx` | the actual transaction object |
7294
- | [input.tx.pk] | `string` | the sender pk |
7295
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7296
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7297
- | [input.tx.chainId] | `string` | the chainId |
7298
- | [input.tx.signature] | `string` | transaction signature |
7299
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7300
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7301
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7189
+ | Name | Type | Description |
7190
+ | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7191
+ | input | `object` | |
7192
+ | input.tx | `object` | data of the transaction |
7193
+ | input.tx.itx | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx) | the actual transaction object |
7194
+ | [input.tx.pk] | `string` | the sender pk |
7195
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7196
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7197
+ | [input.tx.chainId] | `string` | the chainId |
7198
+ | [input.tx.signature] | `string` | transaction signature |
7199
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7200
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7201
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7302
7202
 
7303
- ### GraphQLClient.PauseRollupTxInput : `Object`
7203
+ ### GraphQLClient.UpdateAssetTxInput : `Object`
7304
7204
 
7305
7205
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7306
7206
  **Properties**
@@ -7309,7 +7209,7 @@ Checkout the following snippet for the format of SendTxParams:
7309
7209
  | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7310
7210
  | input | `object` | |
7311
7211
  | input.tx | `object` | data of the transaction |
7312
- | input.tx.itx | [`PauseRollupTx`](#GraphQLClient.PauseRollupTx) | the actual transaction object |
7212
+ | input.tx.itx | [`UpdateAssetTx`](#GraphQLClient.UpdateAssetTx) | the actual transaction object |
7313
7213
  | [input.tx.pk] | `string` | the sender pk |
7314
7214
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7315
7215
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7319,7 +7219,7 @@ Checkout the following snippet for the format of SendTxParams:
7319
7219
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7320
7220
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7321
7221
 
7322
- ### GraphQLClient.ResumeRollupTxInput : `Object`
7222
+ ### GraphQLClient.ConsumeAssetTxInput : `Object`
7323
7223
 
7324
7224
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7325
7225
  **Properties**
@@ -7328,7 +7228,7 @@ Checkout the following snippet for the format of SendTxParams:
7328
7228
  | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7329
7229
  | input | `object` | |
7330
7230
  | input.tx | `object` | data of the transaction |
7331
- | input.tx.itx | [`ResumeRollupTx`](#GraphQLClient.ResumeRollupTx) | the actual transaction object |
7231
+ | input.tx.itx | [`ConsumeAssetTx`](#GraphQLClient.ConsumeAssetTx) | the actual transaction object |
7332
7232
  | [input.tx.pk] | `string` | the sender pk |
7333
7233
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7334
7234
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7338,43 +7238,43 @@ Checkout the following snippet for the format of SendTxParams:
7338
7238
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7339
7239
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7340
7240
 
7341
- ### GraphQLClient.ReturnStakeTxInput : `Object`
7241
+ ### GraphQLClient.CreateFactoryTxInput : `Object`
7342
7242
 
7343
7243
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7344
7244
  **Properties**
7345
7245
 
7346
- | Name | Type | Description |
7347
- | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7348
- | input | `object` | |
7349
- | input.tx | `object` | data of the transaction |
7350
- | input.tx.itx | [`ReturnStakeTx`](#GraphQLClient.ReturnStakeTx) | the actual transaction object |
7351
- | [input.tx.pk] | `string` | the sender pk |
7352
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7353
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7354
- | [input.tx.chainId] | `string` | the chainId |
7355
- | [input.tx.signature] | `string` | transaction signature |
7356
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7357
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7358
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7246
+ | Name | Type | Description |
7247
+ | --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7248
+ | input | `object` | |
7249
+ | input.tx | `object` | data of the transaction |
7250
+ | input.tx.itx | [`CreateFactoryTx`](#GraphQLClient.CreateFactoryTx) | the actual transaction object |
7251
+ | [input.tx.pk] | `string` | the sender pk |
7252
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7253
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7254
+ | [input.tx.chainId] | `string` | the chainId |
7255
+ | [input.tx.signature] | `string` | transaction signature |
7256
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7257
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7258
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7359
7259
 
7360
- ### GraphQLClient.RevokeDelegateTxInput : `Object`
7260
+ ### GraphQLClient.StakeTxInput : `Object`
7361
7261
 
7362
7262
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7363
7263
  **Properties**
7364
7264
 
7365
- | Name | Type | Description |
7366
- | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7367
- | input | `object` | |
7368
- | input.tx | `object` | data of the transaction |
7369
- | input.tx.itx | [`RevokeDelegateTx`](#GraphQLClient.RevokeDelegateTx) | the actual transaction object |
7370
- | [input.tx.pk] | `string` | the sender pk |
7371
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7372
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7373
- | [input.tx.chainId] | `string` | the chainId |
7374
- | [input.tx.signature] | `string` | transaction signature |
7375
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7376
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7377
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7265
+ | Name | Type | Description |
7266
+ | --------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------- |
7267
+ | input | `object` | |
7268
+ | input.tx | `object` | data of the transaction |
7269
+ | input.tx.itx | [`StakeTx`](#GraphQLClient.StakeTx) | the actual transaction object |
7270
+ | [input.tx.pk] | `string` | the sender pk |
7271
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7272
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7273
+ | [input.tx.chainId] | `string` | the chainId |
7274
+ | [input.tx.signature] | `string` | transaction signature |
7275
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7276
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7277
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7378
7278
 
7379
7279
  ### GraphQLClient.RevokeStakeTxInput : `Object`
7380
7280
 
@@ -7395,6 +7295,25 @@ Checkout the following snippet for the format of SendTxParams:
7395
7295
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7396
7296
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7397
7297
 
7298
+ ### GraphQLClient.ClaimStakeTxInput : `Object`
7299
+
7300
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7301
+ **Properties**
7302
+
7303
+ | Name | Type | Description |
7304
+ | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7305
+ | input | `object` | |
7306
+ | input.tx | `object` | data of the transaction |
7307
+ | input.tx.itx | [`ClaimStakeTx`](#GraphQLClient.ClaimStakeTx) | the actual transaction object |
7308
+ | [input.tx.pk] | `string` | the sender pk |
7309
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7310
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7311
+ | [input.tx.chainId] | `string` | the chainId |
7312
+ | [input.tx.signature] | `string` | transaction signature |
7313
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7314
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7315
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7316
+
7398
7317
  ### GraphQLClient.SlashStakeTxInput : `Object`
7399
7318
 
7400
7319
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
@@ -7414,64 +7333,64 @@ Checkout the following snippet for the format of SendTxParams:
7414
7333
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7415
7334
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7416
7335
 
7417
- ### GraphQLClient.StakeTxInput : `Object`
7336
+ ### GraphQLClient.ReturnStakeTxInput : `Object`
7418
7337
 
7419
7338
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7420
7339
  **Properties**
7421
7340
 
7422
- | Name | Type | Description |
7423
- | --------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------- |
7424
- | input | `object` | |
7425
- | input.tx | `object` | data of the transaction |
7426
- | input.tx.itx | [`StakeTx`](#GraphQLClient.StakeTx) | the actual transaction object |
7427
- | [input.tx.pk] | `string` | the sender pk |
7428
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7429
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7430
- | [input.tx.chainId] | `string` | the chainId |
7431
- | [input.tx.signature] | `string` | transaction signature |
7432
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7433
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7434
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7341
+ | Name | Type | Description |
7342
+ | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7343
+ | input | `object` | |
7344
+ | input.tx | `object` | data of the transaction |
7345
+ | input.tx.itx | [`ReturnStakeTx`](#GraphQLClient.ReturnStakeTx) | the actual transaction object |
7346
+ | [input.tx.pk] | `string` | the sender pk |
7347
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7348
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7349
+ | [input.tx.chainId] | `string` | the chainId |
7350
+ | [input.tx.signature] | `string` | transaction signature |
7351
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7352
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7353
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7435
7354
 
7436
- ### GraphQLClient.TransferTxInput : `Object`
7355
+ ### GraphQLClient.CreateRollupTxInput : `Object`
7437
7356
 
7438
7357
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7439
7358
  **Properties**
7440
7359
 
7441
- | Name | Type | Description |
7442
- | --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
7443
- | input | `object` | |
7444
- | input.tx | `object` | data of the transaction |
7445
- | input.tx.itx | [`TransferTx`](#GraphQLClient.TransferTx) | the actual transaction object |
7446
- | [input.tx.pk] | `string` | the sender pk |
7447
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7448
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7449
- | [input.tx.chainId] | `string` | the chainId |
7450
- | [input.tx.signature] | `string` | transaction signature |
7451
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7452
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7453
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7360
+ | Name | Type | Description |
7361
+ | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7362
+ | input | `object` | |
7363
+ | input.tx | `object` | data of the transaction |
7364
+ | input.tx.itx | [`CreateRollupTx`](#GraphQLClient.CreateRollupTx) | the actual transaction object |
7365
+ | [input.tx.pk] | `string` | the sender pk |
7366
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7367
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7368
+ | [input.tx.chainId] | `string` | the chainId |
7369
+ | [input.tx.signature] | `string` | transaction signature |
7370
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7371
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7372
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7454
7373
 
7455
- ### GraphQLClient.TransferV2TxInput : `Object`
7374
+ ### GraphQLClient.UpdateRollupTxInput : `Object`
7456
7375
 
7457
7376
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7458
7377
  **Properties**
7459
7378
 
7460
- | Name | Type | Description |
7461
- | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7462
- | input | `object` | |
7463
- | input.tx | `object` | data of the transaction |
7464
- | input.tx.itx | [`TransferV2Tx`](#GraphQLClient.TransferV2Tx) | the actual transaction object |
7465
- | [input.tx.pk] | `string` | the sender pk |
7466
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7467
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7468
- | [input.tx.chainId] | `string` | the chainId |
7469
- | [input.tx.signature] | `string` | transaction signature |
7470
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7471
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7472
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7379
+ | Name | Type | Description |
7380
+ | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7381
+ | input | `object` | |
7382
+ | input.tx | `object` | data of the transaction |
7383
+ | input.tx.itx | [`UpdateRollupTx`](#GraphQLClient.UpdateRollupTx) | the actual transaction object |
7384
+ | [input.tx.pk] | `string` | the sender pk |
7385
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7386
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7387
+ | [input.tx.chainId] | `string` | the chainId |
7388
+ | [input.tx.signature] | `string` | transaction signature |
7389
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7390
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7391
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7473
7392
 
7474
- ### GraphQLClient.TransferV3TxInput : `Object`
7393
+ ### GraphQLClient.JoinRollupTxInput : `Object`
7475
7394
 
7476
7395
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7477
7396
  **Properties**
@@ -7480,7 +7399,7 @@ Checkout the following snippet for the format of SendTxParams:
7480
7399
  | --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
7481
7400
  | input | `object` | |
7482
7401
  | input.tx | `object` | data of the transaction |
7483
- | input.tx.itx | [`TransferV3Tx`](#GraphQLClient.TransferV3Tx) | the actual transaction object |
7402
+ | input.tx.itx | [`JoinRollupTx`](#GraphQLClient.JoinRollupTx) | the actual transaction object |
7484
7403
  | [input.tx.pk] | `string` | the sender pk |
7485
7404
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7486
7405
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7490,7 +7409,7 @@ Checkout the following snippet for the format of SendTxParams:
7490
7409
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7491
7410
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7492
7411
 
7493
- ### GraphQLClient.UpdateAssetTxInput : `Object`
7412
+ ### GraphQLClient.LeaveRollupTxInput : `Object`
7494
7413
 
7495
7414
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7496
7415
  **Properties**
@@ -7499,7 +7418,7 @@ Checkout the following snippet for the format of SendTxParams:
7499
7418
  | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7500
7419
  | input | `object` | |
7501
7420
  | input.tx | `object` | data of the transaction |
7502
- | input.tx.itx | [`UpdateAssetTx`](#GraphQLClient.UpdateAssetTx) | the actual transaction object |
7421
+ | input.tx.itx | [`LeaveRollupTx`](#GraphQLClient.LeaveRollupTx) | the actual transaction object |
7503
7422
  | [input.tx.pk] | `string` | the sender pk |
7504
7423
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7505
7424
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7509,7 +7428,64 @@ Checkout the following snippet for the format of SendTxParams:
7509
7428
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7510
7429
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7511
7430
 
7512
- ### GraphQLClient.UpdateRollupTxInput : `Object`
7431
+ ### GraphQLClient.CreateRollupBlockTxInput : `Object`
7432
+
7433
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7434
+ **Properties**
7435
+
7436
+ | Name | Type | Description |
7437
+ | --------------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7438
+ | input | `object` | |
7439
+ | input.tx | `object` | data of the transaction |
7440
+ | input.tx.itx | [`CreateRollupBlockTx`](#GraphQLClient.CreateRollupBlockTx) | the actual transaction object |
7441
+ | [input.tx.pk] | `string` | the sender pk |
7442
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7443
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7444
+ | [input.tx.chainId] | `string` | the chainId |
7445
+ | [input.tx.signature] | `string` | transaction signature |
7446
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7447
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7448
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7449
+
7450
+ ### GraphQLClient.ClaimBlockRewardTxInput : `Object`
7451
+
7452
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7453
+ **Properties**
7454
+
7455
+ | Name | Type | Description |
7456
+ | --------------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7457
+ | input | `object` | |
7458
+ | input.tx | `object` | data of the transaction |
7459
+ | input.tx.itx | [`ClaimBlockRewardTx`](#GraphQLClient.ClaimBlockRewardTx) | the actual transaction object |
7460
+ | [input.tx.pk] | `string` | the sender pk |
7461
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7462
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7463
+ | [input.tx.chainId] | `string` | the chainId |
7464
+ | [input.tx.signature] | `string` | transaction signature |
7465
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7466
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7467
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7468
+
7469
+ ### GraphQLClient.PauseRollupTxInput : `Object`
7470
+
7471
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7472
+ **Properties**
7473
+
7474
+ | Name | Type | Description |
7475
+ | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7476
+ | input | `object` | |
7477
+ | input.tx | `object` | data of the transaction |
7478
+ | input.tx.itx | [`PauseRollupTx`](#GraphQLClient.PauseRollupTx) | the actual transaction object |
7479
+ | [input.tx.pk] | `string` | the sender pk |
7480
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7481
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7482
+ | [input.tx.chainId] | `string` | the chainId |
7483
+ | [input.tx.signature] | `string` | transaction signature |
7484
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7485
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7486
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7487
+
7488
+ ### GraphQLClient.ResumeRollupTxInput : `Object`
7513
7489
 
7514
7490
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7515
7491
  **Properties**
@@ -7518,7 +7494,7 @@ Checkout the following snippet for the format of SendTxParams:
7518
7494
  | --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7519
7495
  | input | `object` | |
7520
7496
  | input.tx | `object` | data of the transaction |
7521
- | input.tx.itx | [`UpdateRollupTx`](#GraphQLClient.UpdateRollupTx) | the actual transaction object |
7497
+ | input.tx.itx | [`ResumeRollupTx`](#GraphQLClient.ResumeRollupTx) | the actual transaction object |
7522
7498
  | [input.tx.pk] | `string` | the sender pk |
7523
7499
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7524
7500
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7528,26 +7504,7 @@ Checkout the following snippet for the format of SendTxParams:
7528
7504
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7529
7505
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7530
7506
 
7531
- ### GraphQLClient.UpdateTokenFactoryTxInput : `Object`
7532
-
7533
- **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7534
- **Properties**
7535
-
7536
- | Name | Type | Description |
7537
- | --------------------- | ------------------------------------ | --------------------------------------------------------------------------------------------- |
7538
- | input | `object` | |
7539
- | input.tx | `object` | data of the transaction |
7540
- | input.tx.itx | `GraphQLClient.UpdateTokenFactoryTx` | the actual transaction object |
7541
- | [input.tx.pk] | `string` | the sender pk |
7542
- | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7543
- | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7544
- | [input.tx.chainId] | `string` | the chainId |
7545
- | [input.tx.signature] | `string` | transaction signature |
7546
- | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7547
- | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7548
- | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7549
-
7550
- ### GraphQLClient.UpgradeNodeTxInput : `Object`
7507
+ ### GraphQLClient.CloseRollupTxInput : `Object`
7551
7508
 
7552
7509
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7553
7510
  **Properties**
@@ -7556,7 +7513,7 @@ Checkout the following snippet for the format of SendTxParams:
7556
7513
  | --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
7557
7514
  | input | `object` | |
7558
7515
  | input.tx | `object` | data of the transaction |
7559
- | input.tx.itx | [`UpgradeNodeTx`](#GraphQLClient.UpgradeNodeTx) | the actual transaction object |
7516
+ | input.tx.itx | [`CloseRollupTx`](#GraphQLClient.CloseRollupTx) | the actual transaction object |
7560
7517
  | [input.tx.pk] | `string` | the sender pk |
7561
7518
  | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7562
7519
  | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
@@ -7566,6 +7523,44 @@ Checkout the following snippet for the format of SendTxParams:
7566
7523
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7567
7524
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7568
7525
 
7526
+ ### GraphQLClient.MigrateRollupTxInput : `Object`
7527
+
7528
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7529
+ **Properties**
7530
+
7531
+ | Name | Type | Description |
7532
+ | --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7533
+ | input | `object` | |
7534
+ | input.tx | `object` | data of the transaction |
7535
+ | input.tx.itx | [`MigrateRollupTx`](#GraphQLClient.MigrateRollupTx) | the actual transaction object |
7536
+ | [input.tx.pk] | `string` | the sender pk |
7537
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7538
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7539
+ | [input.tx.chainId] | `string` | the chainId |
7540
+ | [input.tx.signature] | `string` | transaction signature |
7541
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7542
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7543
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7544
+
7545
+ ### GraphQLClient.DepositTokenV2TxInput : `Object`
7546
+
7547
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7548
+ **Properties**
7549
+
7550
+ | Name | Type | Description |
7551
+ | --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7552
+ | input | `object` | |
7553
+ | input.tx | `object` | data of the transaction |
7554
+ | input.tx.itx | [`DepositTokenV2Tx`](#GraphQLClient.DepositTokenV2Tx) | the actual transaction object |
7555
+ | [input.tx.pk] | `string` | the sender pk |
7556
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7557
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7558
+ | [input.tx.chainId] | `string` | the chainId |
7559
+ | [input.tx.signature] | `string` | transaction signature |
7560
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7561
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7562
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7563
+
7569
7564
  ### GraphQLClient.WithdrawTokenV2TxInput : `Object`
7570
7565
 
7571
7566
  **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
@@ -7584,3 +7579,79 @@ Checkout the following snippet for the format of SendTxParams:
7584
7579
  | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7585
7580
  | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7586
7581
  | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7582
+
7583
+ ### GraphQLClient.CreateTokenFactoryTxInput : `Object`
7584
+
7585
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7586
+ **Properties**
7587
+
7588
+ | Name | Type | Description |
7589
+ | --------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7590
+ | input | `object` | |
7591
+ | input.tx | `object` | data of the transaction |
7592
+ | input.tx.itx | [`CreateTokenFactoryTx`](#GraphQLClient.CreateTokenFactoryTx) | the actual transaction object |
7593
+ | [input.tx.pk] | `string` | the sender pk |
7594
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7595
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7596
+ | [input.tx.chainId] | `string` | the chainId |
7597
+ | [input.tx.signature] | `string` | transaction signature |
7598
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7599
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7600
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7601
+
7602
+ ### GraphQLClient.UpdateTokenFactoryTxInput : `Object`
7603
+
7604
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7605
+ **Properties**
7606
+
7607
+ | Name | Type | Description |
7608
+ | --------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
7609
+ | input | `object` | |
7610
+ | input.tx | `object` | data of the transaction |
7611
+ | input.tx.itx | [`UpdateTokenFactoryTx`](#GraphQLClient.UpdateTokenFactoryTx) | the actual transaction object |
7612
+ | [input.tx.pk] | `string` | the sender pk |
7613
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7614
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7615
+ | [input.tx.chainId] | `string` | the chainId |
7616
+ | [input.tx.signature] | `string` | transaction signature |
7617
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7618
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7619
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7620
+
7621
+ ### GraphQLClient.MintTokenTxInput : `Object`
7622
+
7623
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7624
+ **Properties**
7625
+
7626
+ | Name | Type | Description |
7627
+ | --------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------- |
7628
+ | input | `object` | |
7629
+ | input.tx | `object` | data of the transaction |
7630
+ | input.tx.itx | [`MintTokenTx`](#GraphQLClient.MintTokenTx) | the actual transaction object |
7631
+ | [input.tx.pk] | `string` | the sender pk |
7632
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7633
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7634
+ | [input.tx.chainId] | `string` | the chainId |
7635
+ | [input.tx.signature] | `string` | transaction signature |
7636
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7637
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7638
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |
7639
+
7640
+ ### GraphQLClient.BurnTokenTxInput : `Object`
7641
+
7642
+ **Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
7643
+ **Properties**
7644
+
7645
+ | Name | Type | Description |
7646
+ | --------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------- |
7647
+ | input | `object` | |
7648
+ | input.tx | `object` | data of the transaction |
7649
+ | input.tx.itx | [`BurnTokenTx`](#GraphQLClient.BurnTokenTx) | the actual transaction object |
7650
+ | [input.tx.pk] | `string` | the sender pk |
7651
+ | [input.tx.from] | `string` | the sender address, can be derived from wallet |
7652
+ | [input.tx.nonce] | `number` | the tx nonce, defaults to Date.now if not set |
7653
+ | [input.tx.chainId] | `string` | the chainId |
7654
+ | [input.tx.signature] | `string` | transaction signature |
7655
+ | [input.tx.signatures] | `array` | transaction signatures, should be set when it's a multisig transaction |
7656
+ | input.wallet | `object` | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
7657
+ | [input.signature] | `string` | the signature of the tx, if this parameter exist, we will not sign the transaction |