## GraphQLClient

An http client that reads/writes OCAP blockchain data. CBOR-only wire
encoding — browser / Worker / Node bundles stay off the protobuf runtime.

For back-compat with chain nodes that still decode legacy protobuf
transactions, or to test the dual-encoding path end-to-end, import the
`@ocap/client/legacy` subpath which ships both encoders.

Internal protobuf repeated-field naming (`xxxList`) is preserved in
response objects the chain returns — this is a server-side convention.

**Kind**: global class\
**See**

* GraphQLClient#getQueries
* GraphQLClient#getMutations
* GraphQLClient#getSubscriptions
* GraphQLClient#getTxSendMethods
* GraphQLClient#getTxEncodeMethods

<!---->

* [GraphQLClient](#GraphQLClient)
  * [new GraphQLClient(endpoint, autoInit, \[options\])](#new_GraphQLClient_new)
    * *instance*
      * [fromUnitToToken(value)](#GraphQLClient+fromUnitToToken) ⇒ `string`
      * [fromTokenToUnit(amount)](#GraphQLClient+fromTokenToUnit) ⇒ `BN`
      * [getTxSendMethods()](#GraphQLClient+getTxSendMethods) ⇒ `Array.<string>`
      * [getTxEncodeMethods()](#GraphQLClient+getTxEncodeMethods) ⇒ `Array.<string>`
      * [getTxSignMethods()](#GraphQLClient+getTxSignMethods) ⇒ `Array.<string>`
      * [getTxMultiSignMethods()](#GraphQLClient+getTxMultiSignMethods) ⇒ `Array.<string>`
      * [getType(x)](#GraphQLClient+getType) ⇒ `class` | `null`
      * [decodeTx(input)](#GraphQLClient+decodeTx) ⇒ `object`
      * [migrateAccount(params, extra)](#GraphQLClient+migrateAccount) ⇒ `Promise`
      * [delegate(params, extra)](#GraphQLClient+delegate) ⇒ `Promise`
      * [revokeDelegate(params, extra)](#GraphQLClient+revokeDelegate) ⇒ `Promise`
      * [createAsset(params, extra)](#GraphQLClient+createAsset) ⇒ `Promise`
      * [updateAsset(params, extra)](#GraphQLClient+updateAsset) ⇒ `Promise`
      * [createAssetFactory(params, extra)](#GraphQLClient+createAssetFactory) ⇒ `Promise`
      * [acquireAsset(params, extra)](#GraphQLClient+acquireAsset) ⇒ `Promise`
      * [transfer(params, extra)](#GraphQLClient+transfer) ⇒ `Promise`
      * [prepareExchange(params, extra)](#GraphQLClient+prepareExchange) ⇒ `Promise`
      * [finalizeExchange(params, extra)](#GraphQLClient+finalizeExchange) ⇒ `Promise`
      * [exchange(params, extra)](#GraphQLClient+exchange) ⇒ `Promise`
      * [getQueries()](#GraphQLClient+getQueries) ⇒ `Array.<string>`
      * [getMutations()](#GraphQLClient+getMutations) ⇒ `Array.<string>`
      * [getSubscription()](#GraphQLClient+getSubscription) ⇒ `Array.<string>`
      * [doRawQuery(query)](#GraphQLClient+doRawQuery) ⇒ `Promise`
      * [doRawSubscription(query)](#GraphQLClient+doRawSubscription) ⇒ `Promise`
      * [sendAccountMigrateTx(params, extra)](#GraphQLClient+sendAccountMigrateTx) ⇒ `Promise.<string>`
      * [sendDelegateTx(params, extra)](#GraphQLClient+sendDelegateTx) ⇒ `Promise.<string>`
      * [sendRevokeDelegateTx(params, extra)](#GraphQLClient+sendRevokeDelegateTx) ⇒ `Promise.<string>`
      * [sendUpgradeNodeTx(params, extra)](#GraphQLClient+sendUpgradeNodeTx) ⇒ `Promise.<string>`
      * [sendExchangeTx(params, extra)](#GraphQLClient+sendExchangeTx) ⇒ `Promise.<string>`
      * [sendExchangeV2Tx(params, extra)](#GraphQLClient+sendExchangeV2Tx) ⇒ `Promise.<string>`
      * [sendTransferTx(params, extra)](#GraphQLClient+sendTransferTx) ⇒ `Promise.<string>`
      * [sendTransferV2Tx(params, extra)](#GraphQLClient+sendTransferV2Tx) ⇒ `Promise.<string>`
      * [sendTransferV3Tx(params, extra)](#GraphQLClient+sendTransferV3Tx) ⇒ `Promise.<string>`
      * [sendCreateTokenTx(params, extra)](#GraphQLClient+sendCreateTokenTx) ⇒ `Promise.<string>`
      * [sendAcquireAssetV2Tx(params, extra)](#GraphQLClient+sendAcquireAssetV2Tx) ⇒ `Promise.<string>`
      * [sendAcquireAssetV3Tx(params, extra)](#GraphQLClient+sendAcquireAssetV3Tx) ⇒ `Promise.<string>`
      * [sendMintAssetTx(params, extra)](#GraphQLClient+sendMintAssetTx) ⇒ `Promise.<string>`
      * [sendCreateAssetTx(params, extra)](#GraphQLClient+sendCreateAssetTx) ⇒ `Promise.<string>`
      * [sendUpdateAssetTx(params, extra)](#GraphQLClient+sendUpdateAssetTx) ⇒ `Promise.<string>`
      * [sendConsumeAssetTx(params, extra)](#GraphQLClient+sendConsumeAssetTx) ⇒ `Promise.<string>`
      * [sendCreateFactoryTx(params, extra)](#GraphQLClient+sendCreateFactoryTx) ⇒ `Promise.<string>`
      * [sendStakeTx(params, extra)](#GraphQLClient+sendStakeTx) ⇒ `Promise.<string>`
      * [sendRevokeStakeTx(params, extra)](#GraphQLClient+sendRevokeStakeTx) ⇒ `Promise.<string>`
      * [sendClaimStakeTx(params, extra)](#GraphQLClient+sendClaimStakeTx) ⇒ `Promise.<string>`
      * [sendSlashStakeTx(params, extra)](#GraphQLClient+sendSlashStakeTx) ⇒ `Promise.<string>`
      * [sendReturnStakeTx(params, extra)](#GraphQLClient+sendReturnStakeTx) ⇒ `Promise.<string>`
      * [sendCreateRollupTx(params, extra)](#GraphQLClient+sendCreateRollupTx) ⇒ `Promise.<string>`
      * [sendUpdateRollupTx(params, extra)](#GraphQLClient+sendUpdateRollupTx) ⇒ `Promise.<string>`
      * [sendJoinRollupTx(params, extra)](#GraphQLClient+sendJoinRollupTx) ⇒ `Promise.<string>`
      * [sendLeaveRollupTx(params, extra)](#GraphQLClient+sendLeaveRollupTx) ⇒ `Promise.<string>`
      * [sendCreateRollupBlockTx(params, extra)](#GraphQLClient+sendCreateRollupBlockTx) ⇒ `Promise.<string>`
      * [sendClaimBlockRewardTx(params, extra)](#GraphQLClient+sendClaimBlockRewardTx) ⇒ `Promise.<string>`
      * [sendPauseRollupTx(params, extra)](#GraphQLClient+sendPauseRollupTx) ⇒ `Promise.<string>`
      * [sendResumeRollupTx(params, extra)](#GraphQLClient+sendResumeRollupTx) ⇒ `Promise.<string>`
      * [sendCloseRollupTx(params, extra)](#GraphQLClient+sendCloseRollupTx) ⇒ `Promise.<string>`
      * [sendMigrateRollupTx(params, extra)](#GraphQLClient+sendMigrateRollupTx) ⇒ `Promise.<string>`
      * [sendDepositTokenV2Tx(params, extra)](#GraphQLClient+sendDepositTokenV2Tx) ⇒ `Promise.<string>`
      * [sendWithdrawTokenV2Tx(params, extra)](#GraphQLClient+sendWithdrawTokenV2Tx) ⇒ `Promise.<string>`
      * [sendCreateTokenFactoryTx(params, extra)](#GraphQLClient+sendCreateTokenFactoryTx) ⇒ `Promise.<string>`
      * [sendUpdateTokenFactoryTx(params, extra)](#GraphQLClient+sendUpdateTokenFactoryTx) ⇒ `Promise.<string>`
      * [sendMintTokenTx(params, extra)](#GraphQLClient+sendMintTokenTx) ⇒ `Promise.<string>`
      * [sendBurnTokenTx(params, extra)](#GraphQLClient+sendBurnTokenTx) ⇒ `Promise.<string>`
      * [encodeAccountMigrateTx(params)](#GraphQLClient+encodeAccountMigrateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeDelegateTx(params)](#GraphQLClient+encodeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeRevokeDelegateTx(params)](#GraphQLClient+encodeRevokeDelegateTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeUpgradeNodeTx(params)](#GraphQLClient+encodeUpgradeNodeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeExchangeTx(params)](#GraphQLClient+encodeExchangeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeExchangeV2Tx(params)](#GraphQLClient+encodeExchangeV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeTransferTx(params)](#GraphQLClient+encodeTransferTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeTransferV2Tx(params)](#GraphQLClient+encodeTransferV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeTransferV3Tx(params)](#GraphQLClient+encodeTransferV3Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateTokenTx(params)](#GraphQLClient+encodeCreateTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeAcquireAssetV2Tx(params)](#GraphQLClient+encodeAcquireAssetV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeAcquireAssetV3Tx(params)](#GraphQLClient+encodeAcquireAssetV3Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeMintAssetTx(params)](#GraphQLClient+encodeMintAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateAssetTx(params)](#GraphQLClient+encodeCreateAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeUpdateAssetTx(params)](#GraphQLClient+encodeUpdateAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeConsumeAssetTx(params)](#GraphQLClient+encodeConsumeAssetTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateFactoryTx(params)](#GraphQLClient+encodeCreateFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeStakeTx(params)](#GraphQLClient+encodeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeRevokeStakeTx(params)](#GraphQLClient+encodeRevokeStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeClaimStakeTx(params)](#GraphQLClient+encodeClaimStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeSlashStakeTx(params)](#GraphQLClient+encodeSlashStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeReturnStakeTx(params)](#GraphQLClient+encodeReturnStakeTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateRollupTx(params)](#GraphQLClient+encodeCreateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeUpdateRollupTx(params)](#GraphQLClient+encodeUpdateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeJoinRollupTx(params)](#GraphQLClient+encodeJoinRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeLeaveRollupTx(params)](#GraphQLClient+encodeLeaveRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateRollupBlockTx(params)](#GraphQLClient+encodeCreateRollupBlockTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeClaimBlockRewardTx(params)](#GraphQLClient+encodeClaimBlockRewardTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodePauseRollupTx(params)](#GraphQLClient+encodePauseRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeResumeRollupTx(params)](#GraphQLClient+encodeResumeRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCloseRollupTx(params)](#GraphQLClient+encodeCloseRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeMigrateRollupTx(params)](#GraphQLClient+encodeMigrateRollupTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeDepositTokenV2Tx(params)](#GraphQLClient+encodeDepositTokenV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeWithdrawTokenV2Tx(params)](#GraphQLClient+encodeWithdrawTokenV2Tx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeCreateTokenFactoryTx(params)](#GraphQLClient+encodeCreateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeUpdateTokenFactoryTx(params)](#GraphQLClient+encodeUpdateTokenFactoryTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeMintTokenTx(params)](#GraphQLClient+encodeMintTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [encodeBurnTokenTx(params)](#GraphQLClient+encodeBurnTokenTx) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)
      * [getAccountState(params)](#GraphQLClient+getAccountState) ⇒ [`Promise.<ResponseGetAccountState>`](#GraphQLClient.ResponseGetAccountState)
      * [getAssetState(params)](#GraphQLClient+getAssetState) ⇒ [`Promise.<ResponseGetAssetState>`](#GraphQLClient.ResponseGetAssetState)
      * [getFactoryState(params)](#GraphQLClient+getFactoryState) ⇒ [`Promise.<ResponseGetFactoryState>`](#GraphQLClient.ResponseGetFactoryState)
      * [getDelegateState(params)](#GraphQLClient+getDelegateState) ⇒ [`Promise.<ResponseGetDelegateState>`](#GraphQLClient.ResponseGetDelegateState)
      * [getTokenState(params)](#GraphQLClient+getTokenState) ⇒ [`Promise.<ResponseGetTokenState>`](#GraphQLClient.ResponseGetTokenState)
      * [getEvidenceState(params)](#GraphQLClient+getEvidenceState) ⇒ [`Promise.<ResponseGetEvidenceState>`](#GraphQLClient.ResponseGetEvidenceState)
      * [getForgeState(params)](#GraphQLClient+getForgeState) ⇒ [`Promise.<ResponseGetForgeState>`](#GraphQLClient.ResponseGetForgeState)
      * [getTokenFactoryState(params)](#GraphQLClient+getTokenFactoryState) ⇒ [`Promise.<ResponseGetTokenFactoryState>`](#GraphQLClient.ResponseGetTokenFactoryState)
      * [getTx(params)](#GraphQLClient+getTx) ⇒ [`Promise.<ResponseGetTx>`](#GraphQLClient.ResponseGetTx)
      * [getBlock(params)](#GraphQLClient+getBlock) ⇒ [`Promise.<ResponseGetBlock>`](#GraphQLClient.ResponseGetBlock)
      * [getBlocks(params)](#GraphQLClient+getBlocks) ⇒ [`Promise.<ResponseGetBlocks>`](#GraphQLClient.ResponseGetBlocks)
      * [getUnconfirmedTxs(params)](#GraphQLClient+getUnconfirmedTxs) ⇒ [`Promise.<ResponseGetUnconfirmedTxs>`](#GraphQLClient.ResponseGetUnconfirmedTxs)
      * [getChainInfo()](#GraphQLClient+getChainInfo) ⇒ [`Promise.<ResponseGetChainInfo>`](#GraphQLClient.ResponseGetChainInfo)
      * [getConfig(params)](#GraphQLClient+getConfig) ⇒ [`Promise.<ResponseGetConfig>`](#GraphQLClient.ResponseGetConfig)
      * [getNetInfo()](#GraphQLClient+getNetInfo) ⇒ [`Promise.<ResponseGetNetInfo>`](#GraphQLClient.ResponseGetNetInfo)
      * [getNodeInfo()](#GraphQLClient+getNodeInfo) ⇒ [`Promise.<ResponseGetNodeInfo>`](#GraphQLClient.ResponseGetNodeInfo)
      * [getValidatorsInfo()](#GraphQLClient+getValidatorsInfo) ⇒ [`Promise.<ResponseGetValidatorsInfo>`](#GraphQLClient.ResponseGetValidatorsInfo)
      * [getForgeStats()](#GraphQLClient+getForgeStats) ⇒ [`Promise.<ResponseGetForgeStats>`](#GraphQLClient.ResponseGetForgeStats)
      * [listAssetTransactions(params)](#GraphQLClient+listAssetTransactions) ⇒ [`Promise.<ResponseListAssetTransactions>`](#GraphQLClient.ResponseListAssetTransactions)
      * [listAssets(params)](#GraphQLClient+listAssets) ⇒ [`Promise.<ResponseListAssets>`](#GraphQLClient.ResponseListAssets)
      * [listBlocks(params)](#GraphQLClient+listBlocks) ⇒ [`Promise.<ResponseListBlocks>`](#GraphQLClient.ResponseListBlocks)
      * [listTopAccounts(params)](#GraphQLClient+listTopAccounts) ⇒ [`Promise.<ResponseListTopAccounts>`](#GraphQLClient.ResponseListTopAccounts)
      * [listTransactions(params)](#GraphQLClient+listTransactions) ⇒ [`Promise.<ResponseListTransactions>`](#GraphQLClient.ResponseListTransactions)
      * [listTokens(params)](#GraphQLClient+listTokens) ⇒ [`Promise.<ResponseListTokens>`](#GraphQLClient.ResponseListTokens)
      * [listFactories(params)](#GraphQLClient+listFactories) ⇒ [`Promise.<ResponseListFactories>`](#GraphQLClient.ResponseListFactories)
      * [getAccountTokens(params)](#GraphQLClient+getAccountTokens) ⇒ [`Promise.<ResponseGetAccountTokens>`](#GraphQLClient.ResponseGetAccountTokens)
      * [getStakeState(params)](#GraphQLClient+getStakeState) ⇒ [`Promise.<ResponseGetStakeState>`](#GraphQLClient.ResponseGetStakeState)
      * [listStakes(params)](#GraphQLClient+listStakes) ⇒ [`Promise.<ResponseListStakes>`](#GraphQLClient.ResponseListStakes)
      * [getRollupState(params)](#GraphQLClient+getRollupState) ⇒ [`Promise.<ResponseGetRollupState>`](#GraphQLClient.ResponseGetRollupState)
      * [listRollups(params)](#GraphQLClient+listRollups) ⇒ [`Promise.<ResponseListRollups>`](#GraphQLClient.ResponseListRollups)
      * [getRollupBlock(params)](#GraphQLClient+getRollupBlock) ⇒ [`Promise.<ResponseGetRollupBlock>`](#GraphQLClient.ResponseGetRollupBlock)
      * [listRollupBlocks(params)](#GraphQLClient+listRollupBlocks) ⇒ [`Promise.<ResponseListRollupBlocks>`](#GraphQLClient.ResponseListRollupBlocks)
      * [listRollupValidators(params)](#GraphQLClient+listRollupValidators) ⇒ [`Promise.<ResponseListRollupValidators>`](#GraphQLClient.ResponseListRollupValidators)
      * [listDelegations(params)](#GraphQLClient+listDelegations) ⇒ [`Promise.<ResponseListDelegations>`](#GraphQLClient.ResponseListDelegations)
      * [search(params)](#GraphQLClient+search) ⇒ [`Promise.<ResponseSearch>`](#GraphQLClient.ResponseSearch)
      * [estimateGas(params)](#GraphQLClient+estimateGas) ⇒ [`Promise.<ResponseEstimateGas>`](#GraphQLClient.ResponseEstimateGas)
      * [listTokenFlows(params)](#GraphQLClient+listTokenFlows) ⇒ [`Promise.<ResponseListTokenFlows>`](#GraphQLClient.ResponseListTokenFlows)
      * [verifyAccountRisk(params)](#GraphQLClient+verifyAccountRisk) ⇒ [`Promise.<ResponseVerifyAccountRisk>`](#GraphQLClient.ResponseVerifyAccountRisk)
      * [getTokenDistribution(params)](#GraphQLClient+getTokenDistribution) ⇒ [`Promise.<ResponseGetTokenDistribution>`](#GraphQLClient.ResponseGetTokenDistribution)
      * [listTokenFactories(params)](#GraphQLClient+listTokenFactories) ⇒ [`Promise.<ResponseListTokenFactories>`](#GraphQLClient.ResponseListTokenFactories)
      * [sendTx(params)](#GraphQLClient+sendTx) ⇒ [`Promise.<ResponseSendTx>`](#GraphQLClient.ResponseSendTx)
    * *static*
      * [WalletObject](#GraphQLClient.WalletObject) : `Object`
      * [WalletTypeObject](#GraphQLClient.WalletTypeObject) : `Object`
      * [TxEncodeOutput](#GraphQLClient.TxEncodeOutput) : `object`
      * [AccountFilterInput](#GraphQLClient.AccountFilterInput) : `object`
      * [AddressFilterInput](#GraphQLClient.AddressFilterInput) : `object`
      * [AssetFilterInput](#GraphQLClient.AssetFilterInput) : `object`
      * [DelegationFilterInput](#GraphQLClient.DelegationFilterInput) : `object`
      * [FactoryFilterInput](#GraphQLClient.FactoryFilterInput) : `object`
      * [PageInput](#GraphQLClient.PageInput) : `object`
      * [PageOrderInput](#GraphQLClient.PageOrderInput) : `object`
      * [RangeFilterInput](#GraphQLClient.RangeFilterInput) : `object`
      * [RequestEstimateGasInput](#GraphQLClient.RequestEstimateGasInput) : `object`
      * [RequestGetAccountStateInput](#GraphQLClient.RequestGetAccountStateInput) : `object`
      * [RequestGetAccountTokensInput](#GraphQLClient.RequestGetAccountTokensInput) : `object`
      * [RequestGetBlockInput](#GraphQLClient.RequestGetBlockInput) : `object`
      * [RequestGetBlocksInput](#GraphQLClient.RequestGetBlocksInput) : `object`
      * [RequestGetConfigInput](#GraphQLClient.RequestGetConfigInput) : `object`
      * [RequestGetEvidenceStateInput](#GraphQLClient.RequestGetEvidenceStateInput) : `object`
      * [RequestGetRollupBlockInput](#GraphQLClient.RequestGetRollupBlockInput) : `object`
      * [RequestGetStateInput](#GraphQLClient.RequestGetStateInput) : `object`
      * [RequestGetTokenDistributionInput](#GraphQLClient.RequestGetTokenDistributionInput) : `object`
      * [RequestGetTxInput](#GraphQLClient.RequestGetTxInput) : `object`
      * [RequestListAssetTransactionsInput](#GraphQLClient.RequestListAssetTransactionsInput) : `object`
      * [RequestListAssetsInput](#GraphQLClient.RequestListAssetsInput) : `object`
      * [RequestListBlocksInput](#GraphQLClient.RequestListBlocksInput) : `object`
      * [RequestListDelegationsInput](#GraphQLClient.RequestListDelegationsInput) : `object`
      * [RequestListFactoriesInput](#GraphQLClient.RequestListFactoriesInput) : `object`
      * [RequestListRollupBlocksInput](#GraphQLClient.RequestListRollupBlocksInput) : `object`
      * [RequestListRollupValidatorsInput](#GraphQLClient.RequestListRollupValidatorsInput) : `object`
      * [RequestListRollupsInput](#GraphQLClient.RequestListRollupsInput) : `object`
      * [RequestListStakesInput](#GraphQLClient.RequestListStakesInput) : `object`
      * [RequestListTokenFactoriesInput](#GraphQLClient.RequestListTokenFactoriesInput) : `object`
      * [RequestListTokenFlowsInput](#GraphQLClient.RequestListTokenFlowsInput) : `object`
      * [RequestListTokensInput](#GraphQLClient.RequestListTokensInput) : `object`
      * [RequestListTopAccountsInput](#GraphQLClient.RequestListTopAccountsInput) : `object`
      * [RequestListTransactionsInput](#GraphQLClient.RequestListTransactionsInput) : `object`
      * [RequestSearchInput](#GraphQLClient.RequestSearchInput) : `object`
      * [RequestSendTxInput](#GraphQLClient.RequestSendTxInput) : `object`
      * [RequestVerifyAccountRiskInput](#GraphQLClient.RequestVerifyAccountRiskInput) : `object`
      * [RollupFilterInput](#GraphQLClient.RollupFilterInput) : `object`
      * [StakeFilterInput](#GraphQLClient.StakeFilterInput) : `object`
      * [TimeFilterInput](#GraphQLClient.TimeFilterInput) : `object`
      * [TokenFactoryFilterInput](#GraphQLClient.TokenFactoryFilterInput) : `object`
      * [TokenFilterInput](#GraphQLClient.TokenFilterInput) : `object`
      * [TxFilterInput](#GraphQLClient.TxFilterInput) : `object`
      * [TypeFilterInput](#GraphQLClient.TypeFilterInput) : `object`
      * [ValidatorFilterInput](#GraphQLClient.ValidatorFilterInput) : `object`
      * [ValidityFilterInput](#GraphQLClient.ValidityFilterInput) : `object`
      * [WalletInfoInput](#GraphQLClient.WalletInfoInput) : `object`
      * [WalletTypeInput](#GraphQLClient.WalletTypeInput) : `object`
      * [AccountConfig](#GraphQLClient.AccountConfig) : `object`
      * [AccountMigrateTx](#GraphQLClient.AccountMigrateTx) : `object`
      * [AccountState](#GraphQLClient.AccountState) : `object`
      * [AccountToken](#GraphQLClient.AccountToken) : `object`
      * [AcquireAssetV2Tx](#GraphQLClient.AcquireAssetV2Tx) : `object`
      * [AcquireAssetV3Tx](#GraphQLClient.AcquireAssetV3Tx) : `object`
      * [Any](#GraphQLClient.Any) : `object`
      * [AssetFactoryHook](#GraphQLClient.AssetFactoryHook) : `object`
      * [AssetFactoryInput](#GraphQLClient.AssetFactoryInput) : `object`
      * [AssetFactoryState](#GraphQLClient.AssetFactoryState) : `object`
      * [AssetLimit](#GraphQLClient.AssetLimit) : `object`
      * [AssetState](#GraphQLClient.AssetState) : `object`
      * [BlockID](#GraphQLClient.BlockID) : `object`
      * [BlockInfo](#GraphQLClient.BlockInfo) : `object`
      * [BlockInfoSimple](#GraphQLClient.BlockInfoSimple) : `object`
      * [BurnTokenTx](#GraphQLClient.BurnTokenTx) : `object`
      * [ChainInfo](#GraphQLClient.ChainInfo) : `object`
      * [ClaimBlockRewardTx](#GraphQLClient.ClaimBlockRewardTx) : `object`
      * [ClaimStakeTx](#GraphQLClient.ClaimStakeTx) : `object`
      * [CloseRollupTx](#GraphQLClient.CloseRollupTx) : `object`
      * [ConsensusParams](#GraphQLClient.ConsensusParams) : `object`
      * [ConsumeAssetTx](#GraphQLClient.ConsumeAssetTx) : `object`
      * [CreateAssetTx](#GraphQLClient.CreateAssetTx) : `object`
      * [CreateFactoryTx](#GraphQLClient.CreateFactoryTx) : `object`
      * [CreateRollupBlockTx](#GraphQLClient.CreateRollupBlockTx) : `object`
      * [CreateRollupTx](#GraphQLClient.CreateRollupTx) : `object`
      * [CreateTokenFactoryTx](#GraphQLClient.CreateTokenFactoryTx) : `object`
      * [CreateTokenTx](#GraphQLClient.CreateTokenTx) : `object`
      * [CurveConfig](#GraphQLClient.CurveConfig) : `object`
      * [DeclareTx](#GraphQLClient.DeclareTx) : `object`
      * [DelegateConfig](#GraphQLClient.DelegateConfig) : `object`
      * [DelegateLimit](#GraphQLClient.DelegateLimit) : `object`
      * [DelegateOp](#GraphQLClient.DelegateOp) : `object`
      * [DelegateOpState](#GraphQLClient.DelegateOpState) : `object`
      * [DelegateState](#GraphQLClient.DelegateState) : `object`
      * [DelegateTx](#GraphQLClient.DelegateTx) : `object`
      * [DepositTokenV2Tx](#GraphQLClient.DepositTokenV2Tx) : `object`
      * [Evidence](#GraphQLClient.Evidence) : `object`
      * [EvidenceState](#GraphQLClient.EvidenceState) : `object`
      * [ExchangeInfo](#GraphQLClient.ExchangeInfo) : `object`
      * [ExchangeInfoV2](#GraphQLClient.ExchangeInfoV2) : `object`
      * [ExchangeTx](#GraphQLClient.ExchangeTx) : `object`
      * [ExchangeV2Tx](#GraphQLClient.ExchangeV2Tx) : `object`
      * [ForeignToken](#GraphQLClient.ForeignToken) : `object`
      * [ForgeState](#GraphQLClient.ForgeState) : `object`
      * [ForgeStats](#GraphQLClient.ForgeStats) : `object`
      * [ForgeToken](#GraphQLClient.ForgeToken) : `object`
      * [GasEstimate](#GraphQLClient.GasEstimate) : `object`
      * [GeoInfo](#GraphQLClient.GeoInfo) : `object`
      * [IndexedAccountState](#GraphQLClient.IndexedAccountState) : `object`
      * [IndexedAssetState](#GraphQLClient.IndexedAssetState) : `object`
      * [IndexedBlock](#GraphQLClient.IndexedBlock) : `object`
      * [IndexedDelegationState](#GraphQLClient.IndexedDelegationState) : `object`
      * [IndexedFactoryInput](#GraphQLClient.IndexedFactoryInput) : `object`
      * [IndexedFactoryState](#GraphQLClient.IndexedFactoryState) : `object`
      * [IndexedRollupBlock](#GraphQLClient.IndexedRollupBlock) : `object`
      * [IndexedRollupState](#GraphQLClient.IndexedRollupState) : `object`
      * [IndexedRollupValidator](#GraphQLClient.IndexedRollupValidator) : `object`
      * [IndexedStakeState](#GraphQLClient.IndexedStakeState) : `object`
      * [IndexedTokenFactoryState](#GraphQLClient.IndexedTokenFactoryState) : `object`
      * [IndexedTokenFlow](#GraphQLClient.IndexedTokenFlow) : `object`
      * [IndexedTokenInput](#GraphQLClient.IndexedTokenInput) : `object`
      * [IndexedTokenState](#GraphQLClient.IndexedTokenState) : `object`
      * [IndexedTransaction](#GraphQLClient.IndexedTransaction) : `object`
      * [JoinRollupTx](#GraphQLClient.JoinRollupTx) : `object`
      * [KVPair](#GraphQLClient.KVPair) : `object`
      * [LeaveRollupTx](#GraphQLClient.LeaveRollupTx) : `object`
      * [MigrateRollupTx](#GraphQLClient.MigrateRollupTx) : `object`
      * [MintAssetTx](#GraphQLClient.MintAssetTx) : `object`
      * [MintTokenTx](#GraphQLClient.MintTokenTx) : `object`
      * [Multisig](#GraphQLClient.Multisig) : `object`
      * [NFTDisplay](#GraphQLClient.NFTDisplay) : `object`
      * [NFTEndpoint](#GraphQLClient.NFTEndpoint) : `object`
      * [NFTIssuer](#GraphQLClient.NFTIssuer) : `object`
      * [NetInfo](#GraphQLClient.NetInfo) : `object`
      * [NodeInfo](#GraphQLClient.NodeInfo) : `object`
      * [PageInfo](#GraphQLClient.PageInfo) : `object`
      * [PartSetHeader](#GraphQLClient.PartSetHeader) : `object`
      * [PauseRollupTx](#GraphQLClient.PauseRollupTx) : `object`
      * [PeerInfo](#GraphQLClient.PeerInfo) : `object`
      * [PubKey](#GraphQLClient.PubKey) : `object`
      * [RateLimit](#GraphQLClient.RateLimit) : `object`
      * [ReceiptChange](#GraphQLClient.ReceiptChange) : `object`
      * [ResponseEstimateGas](#GraphQLClient.ResponseEstimateGas) : `object`
      * [ResponseGetAccountState](#GraphQLClient.ResponseGetAccountState) : `object`
      * [ResponseGetAccountTokens](#GraphQLClient.ResponseGetAccountTokens) : `object`
      * [ResponseGetAssetState](#GraphQLClient.ResponseGetAssetState) : `object`
      * [ResponseGetBlock](#GraphQLClient.ResponseGetBlock) : `object`
      * [ResponseGetBlocks](#GraphQLClient.ResponseGetBlocks) : `object`
      * [ResponseGetChainInfo](#GraphQLClient.ResponseGetChainInfo) : `object`
      * [ResponseGetConfig](#GraphQLClient.ResponseGetConfig) : `object`
      * [ResponseGetDelegateState](#GraphQLClient.ResponseGetDelegateState) : `object`
      * [ResponseGetEvidenceState](#GraphQLClient.ResponseGetEvidenceState) : `object`
      * [ResponseGetFactoryState](#GraphQLClient.ResponseGetFactoryState) : `object`
      * [ResponseGetForgeState](#GraphQLClient.ResponseGetForgeState) : `object`
      * [ResponseGetForgeStats](#GraphQLClient.ResponseGetForgeStats) : `object`
      * [ResponseGetNetInfo](#GraphQLClient.ResponseGetNetInfo) : `object`
      * [ResponseGetNodeInfo](#GraphQLClient.ResponseGetNodeInfo) : `object`
      * [ResponseGetRollupBlock](#GraphQLClient.ResponseGetRollupBlock) : `object`
      * [ResponseGetRollupState](#GraphQLClient.ResponseGetRollupState) : `object`
      * [ResponseGetStakeState](#GraphQLClient.ResponseGetStakeState) : `object`
      * [ResponseGetTokenDistribution](#GraphQLClient.ResponseGetTokenDistribution) : `object`
      * [ResponseGetTokenFactoryState](#GraphQLClient.ResponseGetTokenFactoryState) : `object`
      * [ResponseGetTokenState](#GraphQLClient.ResponseGetTokenState) : `object`
      * [ResponseGetTx](#GraphQLClient.ResponseGetTx) : `object`
      * [ResponseGetUnconfirmedTxs](#GraphQLClient.ResponseGetUnconfirmedTxs) : `object`
      * [ResponseGetValidatorsInfo](#GraphQLClient.ResponseGetValidatorsInfo) : `object`
      * [ResponseListAssetTransactions](#GraphQLClient.ResponseListAssetTransactions) : `object`
      * [ResponseListAssets](#GraphQLClient.ResponseListAssets) : `object`
      * [ResponseListBlocks](#GraphQLClient.ResponseListBlocks) : `object`
      * [ResponseListDelegations](#GraphQLClient.ResponseListDelegations) : `object`
      * [ResponseListFactories](#GraphQLClient.ResponseListFactories) : `object`
      * [ResponseListRollupBlocks](#GraphQLClient.ResponseListRollupBlocks) : `object`
      * [ResponseListRollupValidators](#GraphQLClient.ResponseListRollupValidators) : `object`
      * [ResponseListRollups](#GraphQLClient.ResponseListRollups) : `object`
      * [ResponseListStakes](#GraphQLClient.ResponseListStakes) : `object`
      * [ResponseListTokenFactories](#GraphQLClient.ResponseListTokenFactories) : `object`
      * [ResponseListTokenFlows](#GraphQLClient.ResponseListTokenFlows) : `object`
      * [ResponseListTokens](#GraphQLClient.ResponseListTokens) : `object`
      * [ResponseListTopAccounts](#GraphQLClient.ResponseListTopAccounts) : `object`
      * [ResponseListTransactions](#GraphQLClient.ResponseListTransactions) : `object`
      * [ResponseSearch](#GraphQLClient.ResponseSearch) : `object`
      * [ResponseSendTx](#GraphQLClient.ResponseSendTx) : `object`
      * [ResponseVerifyAccountRisk](#GraphQLClient.ResponseVerifyAccountRisk) : `object`
      * [ResumeRollupTx](#GraphQLClient.ResumeRollupTx) : `object`
      * [ReturnStakeTx](#GraphQLClient.ReturnStakeTx) : `object`
      * [RevokeDelegateTx](#GraphQLClient.RevokeDelegateTx) : `object`
      * [RevokeStakeTx](#GraphQLClient.RevokeStakeTx) : `object`
      * [RollupBlock](#GraphQLClient.RollupBlock) : `object`
      * [RollupState](#GraphQLClient.RollupState) : `object`
      * [RollupValidator](#GraphQLClient.RollupValidator) : `object`
      * [SearchResult](#GraphQLClient.SearchResult) : `object`
      * [SlashStakeTx](#GraphQLClient.SlashStakeTx) : `object`
      * [StakeState](#GraphQLClient.StakeState) : `object`
      * [StakeTx](#GraphQLClient.StakeTx) : `object`
      * [StateContext](#GraphQLClient.StateContext) : `object`
      * [TokenDistribution](#GraphQLClient.TokenDistribution) : `object`
      * [TokenFactoryState](#GraphQLClient.TokenFactoryState) : `object`
      * [TokenInfo](#GraphQLClient.TokenInfo) : `object`
      * [TokenInput](#GraphQLClient.TokenInput) : `object`
      * [TokenLimit](#GraphQLClient.TokenLimit) : `object`
      * [TokenMeta](#GraphQLClient.TokenMeta) : `object`
      * [TokenState](#GraphQLClient.TokenState) : `object`
      * [TokenSymbol](#GraphQLClient.TokenSymbol) : `object`
      * [Transaction](#GraphQLClient.Transaction) : `object`
      * [TransactionConfig](#GraphQLClient.TransactionConfig) : `object`
      * [TransactionInfo](#GraphQLClient.TransactionInfo) : `object`
      * [TransactionInput](#GraphQLClient.TransactionInput) : `object`
      * [TransactionReceipt](#GraphQLClient.TransactionReceipt) : `object`
      * [TransferTx](#GraphQLClient.TransferTx) : `object`
      * [TransferV2Tx](#GraphQLClient.TransferV2Tx) : `object`
      * [TransferV3Tx](#GraphQLClient.TransferV3Tx) : `object`
      * [TxFeeConfig](#GraphQLClient.TxFeeConfig) : `object`
      * [TxGasConfig](#GraphQLClient.TxGasConfig) : `object`
      * [TxStakeConfig](#GraphQLClient.TxStakeConfig) : `object`
      * [UnconfirmedTxs](#GraphQLClient.UnconfirmedTxs) : `object`
      * [UpdateAssetTx](#GraphQLClient.UpdateAssetTx) : `object`
      * [UpdateRollupTx](#GraphQLClient.UpdateRollupTx) : `object`
      * [UpdateTokenFactoryTx](#GraphQLClient.UpdateTokenFactoryTx) : `object`
      * [UpgradeInfo](#GraphQLClient.UpgradeInfo) : `object`
      * [UpgradeNodeTx](#GraphQLClient.UpgradeNodeTx) : `object`
      * [UpgradeTask](#GraphQLClient.UpgradeTask) : `object`
      * [UpgradeTasks](#GraphQLClient.UpgradeTasks) : `object`
      * [Validator](#GraphQLClient.Validator) : `object`
      * [ValidatorInfo](#GraphQLClient.ValidatorInfo) : `object`
      * [ValidatorsInfo](#GraphQLClient.ValidatorsInfo) : `object`
      * [VariableInput](#GraphQLClient.VariableInput) : `object`
      * [VaultConfig](#GraphQLClient.VaultConfig) : `object`
      * [VerifyAccountRiskResult](#GraphQLClient.VerifyAccountRiskResult) : `object`
      * [VerifyAccountRiskResult\_BalanceRisky](#GraphQLClient.VerifyAccountRiskResult_BalanceRisky) : `object`
      * [Version](#GraphQLClient.Version) : `object`
      * [WalletType](#GraphQLClient.WalletType) : `object`
      * [WithdrawTokenV2Tx](#GraphQLClient.WithdrawTokenV2Tx) : `object`
      * [GetAccountStateParams](#GraphQLClient.GetAccountStateParams) : `object`
      * [GetAssetStateParams](#GraphQLClient.GetAssetStateParams) : `object`
      * [GetFactoryStateParams](#GraphQLClient.GetFactoryStateParams) : `object`
      * [GetDelegateStateParams](#GraphQLClient.GetDelegateStateParams) : `object`
      * [GetTokenStateParams](#GraphQLClient.GetTokenStateParams) : `object`
      * [GetEvidenceStateParams](#GraphQLClient.GetEvidenceStateParams) : `object`
      * [GetForgeStateParams](#GraphQLClient.GetForgeStateParams) : `object`
      * [GetTokenFactoryStateParams](#GraphQLClient.GetTokenFactoryStateParams) : `object`
      * [GetTxParams](#GraphQLClient.GetTxParams) : `object`
      * [GetBlockParams](#GraphQLClient.GetBlockParams) : `object`
      * [GetBlocksParams](#GraphQLClient.GetBlocksParams) : `object`
      * [GetUnconfirmedTxsParams](#GraphQLClient.GetUnconfirmedTxsParams) : `object`
      * [GetConfigParams](#GraphQLClient.GetConfigParams) : `object`
      * [ListAssetTransactionsParams](#GraphQLClient.ListAssetTransactionsParams) : `object`
      * [ListAssetsParams](#GraphQLClient.ListAssetsParams) : `object`
      * [ListBlocksParams](#GraphQLClient.ListBlocksParams) : `object`
      * [ListTopAccountsParams](#GraphQLClient.ListTopAccountsParams) : `object`
      * [ListTransactionsParams](#GraphQLClient.ListTransactionsParams) : `object`
      * [ListTokensParams](#GraphQLClient.ListTokensParams) : `object`
      * [ListFactoriesParams](#GraphQLClient.ListFactoriesParams) : `object`
      * [GetAccountTokensParams](#GraphQLClient.GetAccountTokensParams) : `object`
      * [GetStakeStateParams](#GraphQLClient.GetStakeStateParams) : `object`
      * [ListStakesParams](#GraphQLClient.ListStakesParams) : `object`
      * [GetRollupStateParams](#GraphQLClient.GetRollupStateParams) : `object`
      * [ListRollupsParams](#GraphQLClient.ListRollupsParams) : `object`
      * [GetRollupBlockParams](#GraphQLClient.GetRollupBlockParams) : `object`
      * [ListRollupBlocksParams](#GraphQLClient.ListRollupBlocksParams) : `object`
      * [ListRollupValidatorsParams](#GraphQLClient.ListRollupValidatorsParams) : `object`
      * [ListDelegationsParams](#GraphQLClient.ListDelegationsParams) : `object`
      * [SearchParams](#GraphQLClient.SearchParams) : `object`
      * [EstimateGasParams](#GraphQLClient.EstimateGasParams) : `object`
      * [ListTokenFlowsParams](#GraphQLClient.ListTokenFlowsParams) : `object`
      * [VerifyAccountRiskParams](#GraphQLClient.VerifyAccountRiskParams) : `object`
      * [GetTokenDistributionParams](#GraphQLClient.GetTokenDistributionParams) : `object`
      * [ListTokenFactoriesParams](#GraphQLClient.ListTokenFactoriesParams) : `object`
      * [SendTxParams](#GraphQLClient.SendTxParams) : `object`
      * [AccountMigrateTxInput](#GraphQLClient.AccountMigrateTxInput) : `Object`
      * [DelegateTxInput](#GraphQLClient.DelegateTxInput) : `Object`
      * [RevokeDelegateTxInput](#GraphQLClient.RevokeDelegateTxInput) : `Object`
      * [UpgradeNodeTxInput](#GraphQLClient.UpgradeNodeTxInput) : `Object`
      * [ExchangeTxInput](#GraphQLClient.ExchangeTxInput) : `Object`
      * [ExchangeV2TxInput](#GraphQLClient.ExchangeV2TxInput) : `Object`
      * [TransferTxInput](#GraphQLClient.TransferTxInput) : `Object`
      * [TransferV2TxInput](#GraphQLClient.TransferV2TxInput) : `Object`
      * [TransferV3TxInput](#GraphQLClient.TransferV3TxInput) : `Object`
      * [CreateTokenTxInput](#GraphQLClient.CreateTokenTxInput) : `Object`
      * [AcquireAssetV2TxInput](#GraphQLClient.AcquireAssetV2TxInput) : `Object`
      * [AcquireAssetV3TxInput](#GraphQLClient.AcquireAssetV3TxInput) : `Object`
      * [MintAssetTxInput](#GraphQLClient.MintAssetTxInput) : `Object`
      * [CreateAssetTxInput](#GraphQLClient.CreateAssetTxInput) : `Object`
      * [UpdateAssetTxInput](#GraphQLClient.UpdateAssetTxInput) : `Object`
      * [ConsumeAssetTxInput](#GraphQLClient.ConsumeAssetTxInput) : `Object`
      * [CreateFactoryTxInput](#GraphQLClient.CreateFactoryTxInput) : `Object`
      * [StakeTxInput](#GraphQLClient.StakeTxInput) : `Object`
      * [RevokeStakeTxInput](#GraphQLClient.RevokeStakeTxInput) : `Object`
      * [ClaimStakeTxInput](#GraphQLClient.ClaimStakeTxInput) : `Object`
      * [SlashStakeTxInput](#GraphQLClient.SlashStakeTxInput) : `Object`
      * [ReturnStakeTxInput](#GraphQLClient.ReturnStakeTxInput) : `Object`
      * [CreateRollupTxInput](#GraphQLClient.CreateRollupTxInput) : `Object`
      * [UpdateRollupTxInput](#GraphQLClient.UpdateRollupTxInput) : `Object`
      * [JoinRollupTxInput](#GraphQLClient.JoinRollupTxInput) : `Object`
      * [LeaveRollupTxInput](#GraphQLClient.LeaveRollupTxInput) : `Object`
      * [CreateRollupBlockTxInput](#GraphQLClient.CreateRollupBlockTxInput) : `Object`
      * [ClaimBlockRewardTxInput](#GraphQLClient.ClaimBlockRewardTxInput) : `Object`
      * [PauseRollupTxInput](#GraphQLClient.PauseRollupTxInput) : `Object`
      * [ResumeRollupTxInput](#GraphQLClient.ResumeRollupTxInput) : `Object`
      * [CloseRollupTxInput](#GraphQLClient.CloseRollupTxInput) : `Object`
      * [MigrateRollupTxInput](#GraphQLClient.MigrateRollupTxInput) : `Object`
      * [DepositTokenV2TxInput](#GraphQLClient.DepositTokenV2TxInput) : `Object`
      * [WithdrawTokenV2TxInput](#GraphQLClient.WithdrawTokenV2TxInput) : `Object`
      * [CreateTokenFactoryTxInput](#GraphQLClient.CreateTokenFactoryTxInput) : `Object`
      * [UpdateTokenFactoryTxInput](#GraphQLClient.UpdateTokenFactoryTxInput) : `Object`
      * [MintTokenTxInput](#GraphQLClient.MintTokenTxInput) : `Object`
      * [BurnTokenTxInput](#GraphQLClient.BurnTokenTxInput) : `Object`

### new GraphQLClient(endpoint, autoInit, \[options])

Create an instance of GraphQLClient

| Param     | Type      | Default | Description                       |
| --------- | --------- | ------- | --------------------------------- |
| endpoint  | `string`  |         | the graphql endpoint of the chain |
| autoInit  | `boolean` | `true`  | whether auto warmup context       |
| [options] | `object`  |         | reserved for future use           |

**Example**

```js
const GraphQLClient = require('@ocap/client');

const client = new GraphQLClient('https://beta.abtnetwork.io/api');

const res = await client.getChainInfo();
```

### graphQLClient.fromUnitToToken(value) ⇒ `string`

Format big number presentation amount to token number

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)

| Param | Type     |
| ----- | -------- |
| value | `string` |

### graphQLClient.fromTokenToUnit(amount) ⇒ `BN`

Encode amount to corresponding token big number presentation

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)

| Param  | Type     |
| ------ | -------- |
| amount | `number` |

### graphQLClient.getTxSendMethods() ⇒ `Array.<string>`

List all transaction send methods
Each method can send one kind of transactions supported by forge core, such as `DeclareTx`, `PokeTx`

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list

### graphQLClient.getTxEncodeMethods() ⇒ `Array.<string>`

List all transaction encode methods, each method can be used to encode transaction to buffer and object

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list

### graphQLClient.getTxSignMethods() ⇒ `Array.<string>`

List all transaction sign methods, each method can be used to sign transaction to an object

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list

### graphQLClient.getTxMultiSignMethods() ⇒ `Array.<string>`

List all transaction multi sign methods, each method can be used to do multi sign a transaction

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list

### graphQLClient.getType(x) ⇒ `class` | `null`

Get protobuf message class by name, only supports forge-built-in types

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `class` | `null` - message type

| Param | Type     |
| ----- | -------- |
| x     | `string` |

### graphQLClient.decodeTx(input) ⇒ `object`

Decode transaction buffer/base64/base58 to an object

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `object` - transaction object

| Param | Type                                      |
| ----- | ----------------------------------------- |
| input | `buffer` \| `hex` \| `base48` \| `base64` |

### graphQLClient.migrateAccount(params, extra) ⇒ `Promise`

Migrate current account to a new account

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the transaction hash once resolved

| Param       | Type           | Description                                     |
| ----------- | -------------- | ----------------------------------------------- |
| params      | `object`       |                                                 |
| params.from | `WalletObject` | which account to migrate from                   |
| params.to   | `WalletObject` | which account to migrate to                     |
| extra       | `object`       | other param to underlying client implementation |

### graphQLClient.delegate(params, extra) ⇒ `Promise`

Delegate some privileges to another account
So that that account can send transactions on behalf of the delegator

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `[transactionHash, delegateAddress]` once resolved

| Param             | Type           | Description                                           |
| ----------------- | -------------- | ----------------------------------------------------- |
| params            | `object`       |                                                       |
| params.from       | `WalletObject` | the delegator, who grants the privilege to others     |
| params.to         | `WalletObject` | the delegatee, who is authorized to send transactions |
| params.privileges | `Array`        | the privilege settings                                |
| extra             | `object`       | other param to underlying client implementation       |

### graphQLClient.revokeDelegate(params, extra) ⇒ `Promise`

Revoke a previous delegation

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the transaction hash once resolved

| Param             | Type           | Description                                           |
| ----------------- | -------------- | ----------------------------------------------------- |
| params            | `object`       |                                                       |
| params.from       | `WalletObject` | the delegator, who grants the privilege to others     |
| params.to         | `WalletObject` | the delegatee, who is authorized to send transactions |
| params.privileges | `Array`        | the privilege settings                                |
| extra             | `object`       | other param to underlying client implementation       |

### graphQLClient.createAsset(params, extra) ⇒ `Promise`

Create an new asset (non-fungible-token)

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `[transactionHash, assetAddress]` once resolved

| Param                | Type           | Description                                             |
| -------------------- | -------------- | ------------------------------------------------------- |
| params               | `object`       |                                                         |
| params.moniker       | `string`       | asset name                                              |
| params.parent        | `string`       | asset parent                                            |
| params.data          | `object`       | asset data payload                                      |
| params.ttl           | `number`       | ttl after first consumption                             |
| params.readonly      | `boolean`      | whether the asset can be updated after creation         |
| params.transferrable | `boolean`      | whether the asset can be transferred to another account |
| params.delegator     | `string`       | who authorized this transaction                         |
| params.wallet        | `WalletObject` | the initial owner of the asset                          |
| extra                | `object`       | other param to underlying client implementation         |

### graphQLClient.updateAsset(params, extra) ⇒ `Promise`

Update an existing asset (non-fungible-token)

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `transactionHash` once resolved

| Param            | Type           | Description                                     |
| ---------------- | -------------- | ----------------------------------------------- |
| params           | `object`       |                                                 |
| params.address   | `string`       | asset address                                   |
| params.moniker   | `string`       | asset name                                      |
| params.data      | `object`       | asset data payload                              |
| params.delegator | `string`       | who authorized this transaction                 |
| params.wallet    | `WalletObject` | the wallet to sign the transaction              |
| extra            | `object`       | other param to underlying client implementation |

### graphQLClient.createAssetFactory(params, extra) ⇒ `Promise`

Create an asset factory that can be used to produce multiple assets in a transaction

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `[transactionHash, factoryAddress]` once resolved

| Param                            | Type           | Description                                                        |
| -------------------------------- | -------------- | ------------------------------------------------------------------ |
| params                           | `object`       |                                                                    |
| params.moniker                   | `string`       | asset name                                                         |
| params.factory                   | `object`       | asset factory attributes                                           |
| params.factory.description       | `string`       | asset factory name                                                 |
| params.factory.limit             | `number`       | how many assets can be generated from this factory                 |
| params.factory.price             | `price`        | how much should charge user when acquire asset                     |
| params.factory.template          | `string`       | mustache compatible                                                |
| params.factory.templateVariables | `Array`        | list of allowed template variables                                 |
| params.factory.assetName         | `string`       | protobuf type known to forge that can be used to create this asset |
| params.factory.attributes        | `string`       | attributes for assets that are generated from this factory         |
| params.readonly                  | `boolean`      | whether the asset can be updated after creation                    |
| params.transferrable             | `boolean`      | whether the asset can be transferred to another account            |
| params.delegator                 | `string`       | who authorized this transaction                                    |
| params.wallet                    | `WalletObject` | the initial owner of the asset                                     |
| extra                            | `object`       | other param to underlying client implementation                    |

### graphQLClient.acquireAsset(params, extra) ⇒ `Promise`

Acquire an asset from factory

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `[transactionHash, [assetAddress]]` once resolved

| Param                 | Type           | Description                                                                            |
| --------------------- | -------------- | -------------------------------------------------------------------------------------- |
| params                | `object`       |                                                                                        |
| params.assetFactory   | `string`       | Asset factory address                                                                  |
| params.assetVariables | `Array`        | list of asset variables that can be populated into asset factory template              |
| params.readonly       | `boolean`      | whether the asset can be updated after creation, should match factory settings         |
| params.transferrable  | `boolean`      | whether the asset can be transferred to another account, should match factory settings |
| params.ttl            | `number`       | asset expire                                                                           |
| params.delegator      | `string`       | who authorized this transaction                                                        |
| params.wallet         | `WalletObject` | the initial owner of the asset                                                         |
| extra                 | `object`       | other param to underlying client implementation                                        |

### graphQLClient.transfer(params, extra) ⇒ `Promise`

Transfer token or assets to another account

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `transactionHash` once resolved

| Param            | Type           | Description                                     |
| ---------------- | -------------- | ----------------------------------------------- |
| params           | `object`       |                                                 |
| params.token     | `number`       | how much token can be transferred               |
| params.assets    | `Array`        | which assets should be transferred              |
| params.to        | `string`       | who receive the transfer                        |
| params.memo      | `string`       | transaction note                                |
| params.delegator | `string`       | who authorized this transaction                 |
| params.wallet    | `WalletObject` | the wallet to sign the transaction              |
| extra            | `object`       | other param to underlying client implementation |

### graphQLClient.prepareExchange(params, extra) ⇒ `Promise`

Prepare an exchange transaction between multiple accounts

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `transaction` object once resolved

| Param               | Type           | Description                                     |
| ------------------- | -------------- | ----------------------------------------------- |
| params              | `object`       |                                                 |
| params.offerToken   | `number`       | how much token can be sent                      |
| params.offerAssets  | `Array`        | which assets should be sent                     |
| params.demandToken  | `number`       | how much token can be received                  |
| params.demandAssets | `Array`        | which assets should be received                 |
| params.receiver     | `string`       | who receive the transfer                        |
| params.memo         | `string`       | transaction note                                |
| params.delegator    | `string`       | which assets should be transferred              |
| params.wallet       | `WalletObject` | the wallet who is the offerer                   |
| extra               | `object`       | other param to underlying client implementation |

### graphQLClient.finalizeExchange(params, extra) ⇒ `Promise`

Finalize an exchange transaction between multiple accounts

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `transaction` object once resolved

| Param            | Type           | Description                                     |
| ---------------- | -------------- | ----------------------------------------------- |
| params           | `object`       |                                                 |
| params.tx        | `object`       | the transaction object from `prepareExchange`   |
| params.delegator | `string`       | who authorized this transaction                 |
| params.data      | `object`       | extra data in the multi sig                     |
| params.wallet    | `WalletObject` | the wallet who is the demander                  |
| extra            | `object`       | other param to underlying client implementation |

### graphQLClient.exchange(params, extra) ⇒ `Promise`

Send an exchange transaction

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - the `transactionHash` once resolved

| Param         | Type           | Description                                     |
| ------------- | -------------- | ----------------------------------------------- |
| params        | `object`       |                                                 |
| params.tx     | `object`       | the transaction object from `finalizeExchange`  |
| params.wallet | `WalletObject` | the wallet to sign the transaction              |
| extra         | `object`       | other param to underlying client implementation |

### graphQLClient.getQueries() ⇒ `Array.<string>`

List all query method names

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list\
**Example**

```js
const methods = client.getQueries();
// list of query methods
// [
//   getAccountState,
//   getAssetState,
//   getFactoryState,
//   getDelegateState,
//   getTokenState,
//   getEvidenceState,
//   getForgeState,
//   getTokenFactoryState,
//   getTx,
//   getBlock,
//   getBlocks,
//   getUnconfirmedTxs,
//   getChainInfo,
//   getConfig,
//   getNetInfo,
//   getNodeInfo,
//   getValidatorsInfo,
//   getForgeStats,
//   listAssetTransactions,
//   listAssets,
//   listBlocks,
//   listTopAccounts,
//   listTransactions,
//   listTokens,
//   listFactories,
//   getAccountTokens,
//   getStakeState,
//   listStakes,
//   getRollupState,
//   listRollups,
//   getRollupBlock,
//   listRollupBlocks,
//   listRollupValidators,
//   listDelegations,
//   search,
//   estimateGas,
//   listTokenFlows,
//   verifyAccountRisk,
//   getTokenDistribution,
//   listTokenFactories,
// ]
```

### graphQLClient.getMutations() ⇒ `Array.<string>`

List all mutation method names

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list\
**Example**

```js
const methods = client.getMutations();
// list of mutation methods
// [
//   sendTx,
// ]
```

### graphQLClient.getSubscription() ⇒ `Array.<string>`

List all subscription method names

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Array.<string>` - method name list\
**Example**

```js
const methods = client.getSubscriptions();
// list of subscription methods
// [
// ]
```

### graphQLClient.doRawQuery(query) ⇒ `Promise`

Send raw graphql query to forge graphql endpoint

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - usually axios response data

| Param | Type     | Description          |
| ----- | -------- | -------------------- |
| query | `string` | graphql query string |

**Example**

```js
const res = await client.doRawQuery('
  getChainInfo {
    code
    info {
      address
      blockHeight
    }
  }
');

// Then
// res.getChainInfo.code
// res.getChainInfo.info
```

### graphQLClient.doRawSubscription(query) ⇒ `Promise`

Send raw graphql subscription to forge graphql endpoint

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise` - usually axios response data

| Param | Type     | Description          |
| ----- | -------- | -------------------- |
| query | `string` | graphql query string |

### graphQLClient.sendAccountMigrateTx(params, extra) ⇒ `Promise.<string>`

Send AccountMigrateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AccountMigrateTxInput`](#GraphQLClient.AccountMigrateTxInput) |
| extra  | `object`                                                        |

### graphQLClient.sendDelegateTx(params, extra) ⇒ `Promise.<string>`

Send DelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |
| extra  | `object`                                            |

### graphQLClient.sendRevokeDelegateTx(params, extra) ⇒ `Promise.<string>`

Send RevokeDelegateTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |
| extra  | `object`                                                        |

### graphQLClient.sendUpgradeNodeTx(params, extra) ⇒ `Promise.<string>`

Send UpgradeNodeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendExchangeTx(params, extra) ⇒ `Promise.<string>`

Send ExchangeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |
| extra  | `object`                                            |

### graphQLClient.sendExchangeV2Tx(params, extra) ⇒ `Promise.<string>`

Send ExchangeV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |
| extra  | `object`                                                |

### graphQLClient.sendTransferTx(params, extra) ⇒ `Promise.<string>`

Send TransferTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |
| extra  | `object`                                            |

### graphQLClient.sendTransferV2Tx(params, extra) ⇒ `Promise.<string>`

Send TransferV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |
| extra  | `object`                                                |

### graphQLClient.sendTransferV3Tx(params, extra) ⇒ `Promise.<string>`

Send TransferV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |
| extra  | `object`                                                |

### graphQLClient.sendCreateTokenTx(params, extra) ⇒ `Promise.<string>`

Send CreateTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendAcquireAssetV2Tx(params, extra) ⇒ `Promise.<string>`

Send AcquireAssetV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |
| extra  | `object`                                                        |

### graphQLClient.sendAcquireAssetV3Tx(params, extra) ⇒ `Promise.<string>`

Send AcquireAssetV3Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |
| extra  | `object`                                                        |

### graphQLClient.sendMintAssetTx(params, extra) ⇒ `Promise.<string>`

Send MintAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |
| extra  | `object`                                              |

### graphQLClient.sendCreateAssetTx(params, extra) ⇒ `Promise.<string>`

Send CreateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendUpdateAssetTx(params, extra) ⇒ `Promise.<string>`

Send UpdateAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendConsumeAssetTx(params, extra) ⇒ `Promise.<string>`

Send ConsumeAssetTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |
| extra  | `object`                                                    |

### graphQLClient.sendCreateFactoryTx(params, extra) ⇒ `Promise.<string>`

Send CreateFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |
| extra  | `object`                                                      |

### graphQLClient.sendStakeTx(params, extra) ⇒ `Promise.<string>`

Send StakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                          |
| ------ | --------------------------------------------- |
| params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |
| extra  | `object`                                      |

### graphQLClient.sendRevokeStakeTx(params, extra) ⇒ `Promise.<string>`

Send RevokeStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendClaimStakeTx(params, extra) ⇒ `Promise.<string>`

Send ClaimStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |
| extra  | `object`                                                |

### graphQLClient.sendSlashStakeTx(params, extra) ⇒ `Promise.<string>`

Send SlashStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |
| extra  | `object`                                                |

### graphQLClient.sendReturnStakeTx(params, extra) ⇒ `Promise.<string>`

Send ReturnStakeTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendCreateRollupTx(params, extra) ⇒ `Promise.<string>`

Send CreateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |
| extra  | `object`                                                    |

### graphQLClient.sendUpdateRollupTx(params, extra) ⇒ `Promise.<string>`

Send UpdateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |
| extra  | `object`                                                    |

### graphQLClient.sendJoinRollupTx(params, extra) ⇒ `Promise.<string>`

Send JoinRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |
| extra  | `object`                                                |

### graphQLClient.sendLeaveRollupTx(params, extra) ⇒ `Promise.<string>`

Send LeaveRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendCreateRollupBlockTx(params, extra) ⇒ `Promise.<string>`

Send CreateRollupBlockTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                                  |
| ------ | --------------------------------------------------------------------- |
| params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |
| extra  | `object`                                                              |

### graphQLClient.sendClaimBlockRewardTx(params, extra) ⇒ `Promise.<string>`

Send ClaimBlockRewardTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                                |
| ------ | ------------------------------------------------------------------- |
| params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |
| extra  | `object`                                                            |

### graphQLClient.sendPauseRollupTx(params, extra) ⇒ `Promise.<string>`

Send PauseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendResumeRollupTx(params, extra) ⇒ `Promise.<string>`

Send ResumeRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |
| extra  | `object`                                                    |

### graphQLClient.sendCloseRollupTx(params, extra) ⇒ `Promise.<string>`

Send CloseRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |
| extra  | `object`                                                  |

### graphQLClient.sendMigrateRollupTx(params, extra) ⇒ `Promise.<string>`

Send MigrateRollupTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |
| extra  | `object`                                                      |

### graphQLClient.sendDepositTokenV2Tx(params, extra) ⇒ `Promise.<string>`

Send DepositTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |
| extra  | `object`                                                        |

### graphQLClient.sendWithdrawTokenV2Tx(params, extra) ⇒ `Promise.<string>`

Send WithdrawTokenV2Tx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |
| extra  | `object`                                                          |

### graphQLClient.sendCreateTokenFactoryTx(params, extra) ⇒ `Promise.<string>`

Send CreateTokenFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                                    |
| ------ | ----------------------------------------------------------------------- |
| params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |
| extra  | `object`                                                                |

### graphQLClient.sendUpdateTokenFactoryTx(params, extra) ⇒ `Promise.<string>`

Send UpdateTokenFactoryTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                                    |
| ------ | ----------------------------------------------------------------------- |
| params | [`UpdateTokenFactoryTxInput`](#GraphQLClient.UpdateTokenFactoryTxInput) |
| extra  | `object`                                                                |

### graphQLClient.sendMintTokenTx(params, extra) ⇒ `Promise.<string>`

Send MintTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |
| extra  | `object`                                              |

### graphQLClient.sendBurnTokenTx(params, extra) ⇒ `Promise.<string>`

Send BurnTokenTx transaction and get the hash, use [getTx](#GraphQLClient+getTx) to get transaction detail

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: `Promise.<string>` - returns transaction hash if success, otherwise error was thrown

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |
| extra  | `object`                                              |

### graphQLClient.encodeAccountMigrateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a AccountMigrateTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AccountMigrateTxInput`](#GraphQLClient.AccountMigrateTxInput) |

### graphQLClient.encodeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a DelegateTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`DelegateTxInput`](#GraphQLClient.DelegateTxInput) |

### graphQLClient.encodeRevokeDelegateTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a RevokeDelegateTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`RevokeDelegateTxInput`](#GraphQLClient.RevokeDelegateTxInput) |

### graphQLClient.encodeUpgradeNodeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a UpgradeNodeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`UpgradeNodeTxInput`](#GraphQLClient.UpgradeNodeTxInput) |

### graphQLClient.encodeExchangeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ExchangeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`ExchangeTxInput`](#GraphQLClient.ExchangeTxInput) |

### graphQLClient.encodeExchangeV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ExchangeV2Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`ExchangeV2TxInput`](#GraphQLClient.ExchangeV2TxInput) |

### graphQLClient.encodeTransferTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a TransferTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`TransferTxInput`](#GraphQLClient.TransferTxInput) |

### graphQLClient.encodeTransferV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a TransferV2Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`TransferV2TxInput`](#GraphQLClient.TransferV2TxInput) |

### graphQLClient.encodeTransferV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a TransferV3Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`TransferV3TxInput`](#GraphQLClient.TransferV3TxInput) |

### graphQLClient.encodeCreateTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateTokenTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CreateTokenTxInput`](#GraphQLClient.CreateTokenTxInput) |

### graphQLClient.encodeAcquireAssetV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a AcquireAssetV2Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AcquireAssetV2TxInput`](#GraphQLClient.AcquireAssetV2TxInput) |

### graphQLClient.encodeAcquireAssetV3Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a AcquireAssetV3Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`AcquireAssetV3TxInput`](#GraphQLClient.AcquireAssetV3TxInput) |

### graphQLClient.encodeMintAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a MintAssetTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`MintAssetTxInput`](#GraphQLClient.MintAssetTxInput) |

### graphQLClient.encodeCreateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateAssetTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CreateAssetTxInput`](#GraphQLClient.CreateAssetTxInput) |

### graphQLClient.encodeUpdateAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a UpdateAssetTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`UpdateAssetTxInput`](#GraphQLClient.UpdateAssetTxInput) |

### graphQLClient.encodeConsumeAssetTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ConsumeAssetTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`ConsumeAssetTxInput`](#GraphQLClient.ConsumeAssetTxInput) |

### graphQLClient.encodeCreateFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateFactoryTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`CreateFactoryTxInput`](#GraphQLClient.CreateFactoryTxInput) |

### graphQLClient.encodeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a StakeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                          |
| ------ | --------------------------------------------- |
| params | [`StakeTxInput`](#GraphQLClient.StakeTxInput) |

### graphQLClient.encodeRevokeStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a RevokeStakeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`RevokeStakeTxInput`](#GraphQLClient.RevokeStakeTxInput) |

### graphQLClient.encodeClaimStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ClaimStakeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`ClaimStakeTxInput`](#GraphQLClient.ClaimStakeTxInput) |

### graphQLClient.encodeSlashStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a SlashStakeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`SlashStakeTxInput`](#GraphQLClient.SlashStakeTxInput) |

### graphQLClient.encodeReturnStakeTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ReturnStakeTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`ReturnStakeTxInput`](#GraphQLClient.ReturnStakeTxInput) |

### graphQLClient.encodeCreateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`CreateRollupTxInput`](#GraphQLClient.CreateRollupTxInput) |

### graphQLClient.encodeUpdateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a UpdateRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`UpdateRollupTxInput`](#GraphQLClient.UpdateRollupTxInput) |

### graphQLClient.encodeJoinRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a JoinRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`JoinRollupTxInput`](#GraphQLClient.JoinRollupTxInput) |

### graphQLClient.encodeLeaveRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a LeaveRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`LeaveRollupTxInput`](#GraphQLClient.LeaveRollupTxInput) |

### graphQLClient.encodeCreateRollupBlockTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateRollupBlockTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                                  |
| ------ | --------------------------------------------------------------------- |
| params | [`CreateRollupBlockTxInput`](#GraphQLClient.CreateRollupBlockTxInput) |

### graphQLClient.encodeClaimBlockRewardTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ClaimBlockRewardTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                                |
| ------ | ------------------------------------------------------------------- |
| params | [`ClaimBlockRewardTxInput`](#GraphQLClient.ClaimBlockRewardTxInput) |

### graphQLClient.encodePauseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a PauseRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`PauseRollupTxInput`](#GraphQLClient.PauseRollupTxInput) |

### graphQLClient.encodeResumeRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a ResumeRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`ResumeRollupTxInput`](#GraphQLClient.ResumeRollupTxInput) |

### graphQLClient.encodeCloseRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CloseRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                      |
| ------ | --------------------------------------------------------- |
| params | [`CloseRollupTxInput`](#GraphQLClient.CloseRollupTxInput) |

### graphQLClient.encodeMigrateRollupTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a MigrateRollupTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`MigrateRollupTxInput`](#GraphQLClient.MigrateRollupTxInput) |

### graphQLClient.encodeDepositTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a DepositTokenV2Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`DepositTokenV2TxInput`](#GraphQLClient.DepositTokenV2TxInput) |

### graphQLClient.encodeWithdrawTokenV2Tx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a WithdrawTokenV2Tx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`WithdrawTokenV2TxInput`](#GraphQLClient.WithdrawTokenV2TxInput) |

### graphQLClient.encodeCreateTokenFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a CreateTokenFactoryTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                                    |
| ------ | ----------------------------------------------------------------------- |
| params | [`CreateTokenFactoryTxInput`](#GraphQLClient.CreateTokenFactoryTxInput) |

### graphQLClient.encodeUpdateTokenFactoryTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a UpdateTokenFactoryTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                                    |
| ------ | ----------------------------------------------------------------------- |
| params | [`UpdateTokenFactoryTxInput`](#GraphQLClient.UpdateTokenFactoryTxInput) |

### graphQLClient.encodeMintTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a MintTokenTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`MintTokenTxInput`](#GraphQLClient.MintTokenTxInput) |

### graphQLClient.encodeBurnTokenTx(params) ⇒ [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput)

Encode a BurnTokenTx transaction for later use

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<TxEncodeOutput>`](#GraphQLClient.TxEncodeOutput) - result - we provide two formats of the encoding result, binary presentation and human readable object

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`BurnTokenTxInput`](#GraphQLClient.BurnTokenTxInput) |

### graphQLClient.getAccountState(params) ⇒ [`Promise.<ResponseGetAccountState>`](#GraphQLClient.ResponseGetAccountState)

getAccountState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetAccountState>`](#GraphQLClient.ResponseGetAccountState) - Checkout [ResponseGetAccountState](#GraphQLClient.ResponseGetAccountState) for resolved data format

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`GetAccountStateParams`](#GraphQLClient.GetAccountStateParams) |

### graphQLClient.getAssetState(params) ⇒ [`Promise.<ResponseGetAssetState>`](#GraphQLClient.ResponseGetAssetState)

getAssetState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetAssetState>`](#GraphQLClient.ResponseGetAssetState) - Checkout [ResponseGetAssetState](#GraphQLClient.ResponseGetAssetState) for resolved data format

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`GetAssetStateParams`](#GraphQLClient.GetAssetStateParams) |

### graphQLClient.getFactoryState(params) ⇒ [`Promise.<ResponseGetFactoryState>`](#GraphQLClient.ResponseGetFactoryState)

getFactoryState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetFactoryState>`](#GraphQLClient.ResponseGetFactoryState) - Checkout [ResponseGetFactoryState](#GraphQLClient.ResponseGetFactoryState) for resolved data format

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`GetFactoryStateParams`](#GraphQLClient.GetFactoryStateParams) |

### graphQLClient.getDelegateState(params) ⇒ [`Promise.<ResponseGetDelegateState>`](#GraphQLClient.ResponseGetDelegateState)

getDelegateState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetDelegateState>`](#GraphQLClient.ResponseGetDelegateState) - Checkout [ResponseGetDelegateState](#GraphQLClient.ResponseGetDelegateState) for resolved data format

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`GetDelegateStateParams`](#GraphQLClient.GetDelegateStateParams) |

### graphQLClient.getTokenState(params) ⇒ [`Promise.<ResponseGetTokenState>`](#GraphQLClient.ResponseGetTokenState)

getTokenState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetTokenState>`](#GraphQLClient.ResponseGetTokenState) - Checkout [ResponseGetTokenState](#GraphQLClient.ResponseGetTokenState) for resolved data format

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`GetTokenStateParams`](#GraphQLClient.GetTokenStateParams) |

### graphQLClient.getEvidenceState(params) ⇒ [`Promise.<ResponseGetEvidenceState>`](#GraphQLClient.ResponseGetEvidenceState)

getEvidenceState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetEvidenceState>`](#GraphQLClient.ResponseGetEvidenceState) - Checkout [ResponseGetEvidenceState](#GraphQLClient.ResponseGetEvidenceState) for resolved data format

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`GetEvidenceStateParams`](#GraphQLClient.GetEvidenceStateParams) |

### graphQLClient.getForgeState(params) ⇒ [`Promise.<ResponseGetForgeState>`](#GraphQLClient.ResponseGetForgeState)

getForgeState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetForgeState>`](#GraphQLClient.ResponseGetForgeState) - Checkout [ResponseGetForgeState](#GraphQLClient.ResponseGetForgeState) for resolved data format

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`GetForgeStateParams`](#GraphQLClient.GetForgeStateParams) |

### graphQLClient.getTokenFactoryState(params) ⇒ [`Promise.<ResponseGetTokenFactoryState>`](#GraphQLClient.ResponseGetTokenFactoryState)

getTokenFactoryState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetTokenFactoryState>`](#GraphQLClient.ResponseGetTokenFactoryState) - Checkout [ResponseGetTokenFactoryState](#GraphQLClient.ResponseGetTokenFactoryState) for resolved data format

| Param  | Type                                                                      |
| ------ | ------------------------------------------------------------------------- |
| params | [`GetTokenFactoryStateParams`](#GraphQLClient.GetTokenFactoryStateParams) |

### graphQLClient.getTx(params) ⇒ [`Promise.<ResponseGetTx>`](#GraphQLClient.ResponseGetTx)

getTx

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetTx>`](#GraphQLClient.ResponseGetTx) - Checkout [ResponseGetTx](#GraphQLClient.ResponseGetTx) for resolved data format

| Param  | Type                                        |
| ------ | ------------------------------------------- |
| params | [`GetTxParams`](#GraphQLClient.GetTxParams) |

### graphQLClient.getBlock(params) ⇒ [`Promise.<ResponseGetBlock>`](#GraphQLClient.ResponseGetBlock)

getBlock

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetBlock>`](#GraphQLClient.ResponseGetBlock) - Checkout [ResponseGetBlock](#GraphQLClient.ResponseGetBlock) for resolved data format

| Param  | Type                                              |
| ------ | ------------------------------------------------- |
| params | [`GetBlockParams`](#GraphQLClient.GetBlockParams) |

### graphQLClient.getBlocks(params) ⇒ [`Promise.<ResponseGetBlocks>`](#GraphQLClient.ResponseGetBlocks)

getBlocks

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetBlocks>`](#GraphQLClient.ResponseGetBlocks) - Checkout [ResponseGetBlocks](#GraphQLClient.ResponseGetBlocks) for resolved data format

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`GetBlocksParams`](#GraphQLClient.GetBlocksParams) |

### graphQLClient.getUnconfirmedTxs(params) ⇒ [`Promise.<ResponseGetUnconfirmedTxs>`](#GraphQLClient.ResponseGetUnconfirmedTxs)

getUnconfirmedTxs

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetUnconfirmedTxs>`](#GraphQLClient.ResponseGetUnconfirmedTxs) - Checkout [ResponseGetUnconfirmedTxs](#GraphQLClient.ResponseGetUnconfirmedTxs) for resolved data format

| Param  | Type                                                                |
| ------ | ------------------------------------------------------------------- |
| params | [`GetUnconfirmedTxsParams`](#GraphQLClient.GetUnconfirmedTxsParams) |

### graphQLClient.getChainInfo() ⇒ [`Promise.<ResponseGetChainInfo>`](#GraphQLClient.ResponseGetChainInfo)

getChainInfo

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetChainInfo>`](#GraphQLClient.ResponseGetChainInfo) - Checkout [ResponseGetChainInfo](#GraphQLClient.ResponseGetChainInfo) for resolved data format

### graphQLClient.getConfig(params) ⇒ [`Promise.<ResponseGetConfig>`](#GraphQLClient.ResponseGetConfig)

getConfig

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetConfig>`](#GraphQLClient.ResponseGetConfig) - Checkout [ResponseGetConfig](#GraphQLClient.ResponseGetConfig) for resolved data format

| Param  | Type                                                |
| ------ | --------------------------------------------------- |
| params | [`GetConfigParams`](#GraphQLClient.GetConfigParams) |

### graphQLClient.getNetInfo() ⇒ [`Promise.<ResponseGetNetInfo>`](#GraphQLClient.ResponseGetNetInfo)

getNetInfo

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetNetInfo>`](#GraphQLClient.ResponseGetNetInfo) - Checkout [ResponseGetNetInfo](#GraphQLClient.ResponseGetNetInfo) for resolved data format

### graphQLClient.getNodeInfo() ⇒ [`Promise.<ResponseGetNodeInfo>`](#GraphQLClient.ResponseGetNodeInfo)

getNodeInfo

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetNodeInfo>`](#GraphQLClient.ResponseGetNodeInfo) - Checkout [ResponseGetNodeInfo](#GraphQLClient.ResponseGetNodeInfo) for resolved data format

### graphQLClient.getValidatorsInfo() ⇒ [`Promise.<ResponseGetValidatorsInfo>`](#GraphQLClient.ResponseGetValidatorsInfo)

getValidatorsInfo

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetValidatorsInfo>`](#GraphQLClient.ResponseGetValidatorsInfo) - Checkout [ResponseGetValidatorsInfo](#GraphQLClient.ResponseGetValidatorsInfo) for resolved data format

### graphQLClient.getForgeStats() ⇒ [`Promise.<ResponseGetForgeStats>`](#GraphQLClient.ResponseGetForgeStats)

getForgeStats

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetForgeStats>`](#GraphQLClient.ResponseGetForgeStats) - Checkout [ResponseGetForgeStats](#GraphQLClient.ResponseGetForgeStats) for resolved data format

### graphQLClient.listAssetTransactions(params) ⇒ [`Promise.<ResponseListAssetTransactions>`](#GraphQLClient.ResponseListAssetTransactions)

listAssetTransactions

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListAssetTransactions>`](#GraphQLClient.ResponseListAssetTransactions) - Checkout [ResponseListAssetTransactions](#GraphQLClient.ResponseListAssetTransactions) for resolved data format

| Param  | Type                                                                        |
| ------ | --------------------------------------------------------------------------- |
| params | [`ListAssetTransactionsParams`](#GraphQLClient.ListAssetTransactionsParams) |

### graphQLClient.listAssets(params) ⇒ [`Promise.<ResponseListAssets>`](#GraphQLClient.ResponseListAssets)

listAssets

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListAssets>`](#GraphQLClient.ResponseListAssets) - Checkout [ResponseListAssets](#GraphQLClient.ResponseListAssets) for resolved data format

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`ListAssetsParams`](#GraphQLClient.ListAssetsParams) |

### graphQLClient.listBlocks(params) ⇒ [`Promise.<ResponseListBlocks>`](#GraphQLClient.ResponseListBlocks)

listBlocks

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListBlocks>`](#GraphQLClient.ResponseListBlocks) - Checkout [ResponseListBlocks](#GraphQLClient.ResponseListBlocks) for resolved data format

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`ListBlocksParams`](#GraphQLClient.ListBlocksParams) |

### graphQLClient.listTopAccounts(params) ⇒ [`Promise.<ResponseListTopAccounts>`](#GraphQLClient.ResponseListTopAccounts)

listTopAccounts

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListTopAccounts>`](#GraphQLClient.ResponseListTopAccounts) - Checkout [ResponseListTopAccounts](#GraphQLClient.ResponseListTopAccounts) for resolved data format

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`ListTopAccountsParams`](#GraphQLClient.ListTopAccountsParams) |

### graphQLClient.listTransactions(params) ⇒ [`Promise.<ResponseListTransactions>`](#GraphQLClient.ResponseListTransactions)

listTransactions

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListTransactions>`](#GraphQLClient.ResponseListTransactions) - Checkout [ResponseListTransactions](#GraphQLClient.ResponseListTransactions) for resolved data format

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`ListTransactionsParams`](#GraphQLClient.ListTransactionsParams) |

### graphQLClient.listTokens(params) ⇒ [`Promise.<ResponseListTokens>`](#GraphQLClient.ResponseListTokens)

listTokens

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListTokens>`](#GraphQLClient.ResponseListTokens) - Checkout [ResponseListTokens](#GraphQLClient.ResponseListTokens) for resolved data format

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`ListTokensParams`](#GraphQLClient.ListTokensParams) |

### graphQLClient.listFactories(params) ⇒ [`Promise.<ResponseListFactories>`](#GraphQLClient.ResponseListFactories)

listFactories

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListFactories>`](#GraphQLClient.ResponseListFactories) - Checkout [ResponseListFactories](#GraphQLClient.ResponseListFactories) for resolved data format

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`ListFactoriesParams`](#GraphQLClient.ListFactoriesParams) |

### graphQLClient.getAccountTokens(params) ⇒ [`Promise.<ResponseGetAccountTokens>`](#GraphQLClient.ResponseGetAccountTokens)

getAccountTokens

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetAccountTokens>`](#GraphQLClient.ResponseGetAccountTokens) - Checkout [ResponseGetAccountTokens](#GraphQLClient.ResponseGetAccountTokens) for resolved data format

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`GetAccountTokensParams`](#GraphQLClient.GetAccountTokensParams) |

### graphQLClient.getStakeState(params) ⇒ [`Promise.<ResponseGetStakeState>`](#GraphQLClient.ResponseGetStakeState)

getStakeState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetStakeState>`](#GraphQLClient.ResponseGetStakeState) - Checkout [ResponseGetStakeState](#GraphQLClient.ResponseGetStakeState) for resolved data format

| Param  | Type                                                        |
| ------ | ----------------------------------------------------------- |
| params | [`GetStakeStateParams`](#GraphQLClient.GetStakeStateParams) |

### graphQLClient.listStakes(params) ⇒ [`Promise.<ResponseListStakes>`](#GraphQLClient.ResponseListStakes)

listStakes

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListStakes>`](#GraphQLClient.ResponseListStakes) - Checkout [ResponseListStakes](#GraphQLClient.ResponseListStakes) for resolved data format

| Param  | Type                                                  |
| ------ | ----------------------------------------------------- |
| params | [`ListStakesParams`](#GraphQLClient.ListStakesParams) |

### graphQLClient.getRollupState(params) ⇒ [`Promise.<ResponseGetRollupState>`](#GraphQLClient.ResponseGetRollupState)

getRollupState

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetRollupState>`](#GraphQLClient.ResponseGetRollupState) - Checkout [ResponseGetRollupState](#GraphQLClient.ResponseGetRollupState) for resolved data format

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`GetRollupStateParams`](#GraphQLClient.GetRollupStateParams) |

### graphQLClient.listRollups(params) ⇒ [`Promise.<ResponseListRollups>`](#GraphQLClient.ResponseListRollups)

listRollups

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListRollups>`](#GraphQLClient.ResponseListRollups) - Checkout [ResponseListRollups](#GraphQLClient.ResponseListRollups) for resolved data format

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`ListRollupsParams`](#GraphQLClient.ListRollupsParams) |

### graphQLClient.getRollupBlock(params) ⇒ [`Promise.<ResponseGetRollupBlock>`](#GraphQLClient.ResponseGetRollupBlock)

getRollupBlock

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetRollupBlock>`](#GraphQLClient.ResponseGetRollupBlock) - Checkout [ResponseGetRollupBlock](#GraphQLClient.ResponseGetRollupBlock) for resolved data format

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`GetRollupBlockParams`](#GraphQLClient.GetRollupBlockParams) |

### graphQLClient.listRollupBlocks(params) ⇒ [`Promise.<ResponseListRollupBlocks>`](#GraphQLClient.ResponseListRollupBlocks)

listRollupBlocks

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListRollupBlocks>`](#GraphQLClient.ResponseListRollupBlocks) - Checkout [ResponseListRollupBlocks](#GraphQLClient.ResponseListRollupBlocks) for resolved data format

| Param  | Type                                                              |
| ------ | ----------------------------------------------------------------- |
| params | [`ListRollupBlocksParams`](#GraphQLClient.ListRollupBlocksParams) |

### graphQLClient.listRollupValidators(params) ⇒ [`Promise.<ResponseListRollupValidators>`](#GraphQLClient.ResponseListRollupValidators)

listRollupValidators

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListRollupValidators>`](#GraphQLClient.ResponseListRollupValidators) - Checkout [ResponseListRollupValidators](#GraphQLClient.ResponseListRollupValidators) for resolved data format

| Param  | Type                                                                      |
| ------ | ------------------------------------------------------------------------- |
| params | [`ListRollupValidatorsParams`](#GraphQLClient.ListRollupValidatorsParams) |

### graphQLClient.listDelegations(params) ⇒ [`Promise.<ResponseListDelegations>`](#GraphQLClient.ResponseListDelegations)

listDelegations

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListDelegations>`](#GraphQLClient.ResponseListDelegations) - Checkout [ResponseListDelegations](#GraphQLClient.ResponseListDelegations) for resolved data format

| Param  | Type                                                            |
| ------ | --------------------------------------------------------------- |
| params | [`ListDelegationsParams`](#GraphQLClient.ListDelegationsParams) |

### graphQLClient.search(params) ⇒ [`Promise.<ResponseSearch>`](#GraphQLClient.ResponseSearch)

search

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseSearch>`](#GraphQLClient.ResponseSearch) - Checkout [ResponseSearch](#GraphQLClient.ResponseSearch) for resolved data format

| Param  | Type                                          |
| ------ | --------------------------------------------- |
| params | [`SearchParams`](#GraphQLClient.SearchParams) |

### graphQLClient.estimateGas(params) ⇒ [`Promise.<ResponseEstimateGas>`](#GraphQLClient.ResponseEstimateGas)

estimateGas

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseEstimateGas>`](#GraphQLClient.ResponseEstimateGas) - Checkout [ResponseEstimateGas](#GraphQLClient.ResponseEstimateGas) for resolved data format

| Param  | Type                                                    |
| ------ | ------------------------------------------------------- |
| params | [`EstimateGasParams`](#GraphQLClient.EstimateGasParams) |

### graphQLClient.listTokenFlows(params) ⇒ [`Promise.<ResponseListTokenFlows>`](#GraphQLClient.ResponseListTokenFlows)

listTokenFlows

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListTokenFlows>`](#GraphQLClient.ResponseListTokenFlows) - Checkout [ResponseListTokenFlows](#GraphQLClient.ResponseListTokenFlows) for resolved data format

| Param  | Type                                                          |
| ------ | ------------------------------------------------------------- |
| params | [`ListTokenFlowsParams`](#GraphQLClient.ListTokenFlowsParams) |

### graphQLClient.verifyAccountRisk(params) ⇒ [`Promise.<ResponseVerifyAccountRisk>`](#GraphQLClient.ResponseVerifyAccountRisk)

verifyAccountRisk

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseVerifyAccountRisk>`](#GraphQLClient.ResponseVerifyAccountRisk) - Checkout [ResponseVerifyAccountRisk](#GraphQLClient.ResponseVerifyAccountRisk) for resolved data format

| Param  | Type                                                                |
| ------ | ------------------------------------------------------------------- |
| params | [`VerifyAccountRiskParams`](#GraphQLClient.VerifyAccountRiskParams) |

### graphQLClient.getTokenDistribution(params) ⇒ [`Promise.<ResponseGetTokenDistribution>`](#GraphQLClient.ResponseGetTokenDistribution)

getTokenDistribution

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseGetTokenDistribution>`](#GraphQLClient.ResponseGetTokenDistribution) - Checkout [ResponseGetTokenDistribution](#GraphQLClient.ResponseGetTokenDistribution) for resolved data format

| Param  | Type                                                                      |
| ------ | ------------------------------------------------------------------------- |
| params | [`GetTokenDistributionParams`](#GraphQLClient.GetTokenDistributionParams) |

### graphQLClient.listTokenFactories(params) ⇒ [`Promise.<ResponseListTokenFactories>`](#GraphQLClient.ResponseListTokenFactories)

listTokenFactories

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseListTokenFactories>`](#GraphQLClient.ResponseListTokenFactories) - Checkout [ResponseListTokenFactories](#GraphQLClient.ResponseListTokenFactories) for resolved data format

| Param  | Type                                                                  |
| ------ | --------------------------------------------------------------------- |
| params | [`ListTokenFactoriesParams`](#GraphQLClient.ListTokenFactoriesParams) |

### graphQLClient.sendTx(params) ⇒ [`Promise.<ResponseSendTx>`](#GraphQLClient.ResponseSendTx)

sendTx

**Kind**: instance method of [`GraphQLClient`](#GraphQLClient)\
**Returns**: [`Promise.<ResponseSendTx>`](#GraphQLClient.ResponseSendTx) - Checkout [ResponseSendTx](#GraphQLClient.ResponseSendTx) for resolved data format

| Param  | Type                                          |
| ------ | --------------------------------------------- |
| params | [`SendTxParams`](#GraphQLClient.SendTxParams) |

### GraphQLClient.WalletObject : `Object`

Structure of GraphQLClient.WalletObject

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                             |
| --------- | -------------------------------- |
| publicKey | `string`                         |
| secretKey | `string`                         |
| type      | `GraphQLClient~WalletTypeObject` |

### GraphQLClient.WalletTypeObject : `Object`

Structure of GraphQLClient.WalletTypeObject

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     | Description           |
| ------- | -------- | --------------------- |
| pk      | `number` |                       |
| role    | `number` |                       |
| hash    | `number` |                       |
| address | `number` | defaults to base58btc |

### GraphQLClient.TxEncodeOutput : `object`

Structure of GraphQLClient.TxEncodeOutput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type     | Description                                                                            |
| ------ | -------- | -------------------------------------------------------------------------------------- |
| object | `object` | the transaction object, human readable                                                 |
| buffer | `buffer` | the transaction binary presentation, can be used to signing, encoding to other formats |

### GraphQLClient.AccountFilterInput : `object`

Structure of GraphQLClient.AccountFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type             |
| -------- | ---------------- |
| accounts | `Array.<string>` |

### GraphQLClient.AddressFilterInput : `object`

Structure of GraphQLClient.AddressFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                      |
| ------------ | ------------------------- |
| sender       | `string`                  |
| receiver     | `string`                  |
| ...direction | `GraphQLClient.Direction` |

### GraphQLClient.AssetFilterInput : `object`

Structure of GraphQLClient.AssetFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type             |
| ------ | ---------------- |
| assets | `Array.<string>` |

### GraphQLClient.DelegationFilterInput : `object`

Structure of GraphQLClient.DelegationFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type             |
| ----------- | ---------------- |
| delegations | `Array.<string>` |

### GraphQLClient.FactoryFilterInput : `object`

Structure of GraphQLClient.FactoryFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type             |
| --------- | ---------------- |
| factories | `Array.<string>` |

### GraphQLClient.PageInput : `object`

Structure of GraphQLClient.PageInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type                                      |
| ------ | ----------------------------------------- |
| cursor | `string`                                  |
| size   | `number`                                  |
| order  | `Array.<...GraphQLClient.PageOrderInput>` |

### GraphQLClient.PageOrderInput : `object`

Structure of GraphQLClient.PageOrderInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| field | `string` |
| type  | `string` |

### GraphQLClient.RangeFilterInput : `object`

Structure of GraphQLClient.RangeFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| from | `string` |
| to   | `string` |

### GraphQLClient.RequestEstimateGasInput : `object`

Structure of GraphQLClient.RequestEstimateGasInput

Checkout the following snippet for the format of RequestEstimateGasInput:

```json
{
  "typeUrl": "abc",
  "tx": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| typeUrl | `string` |
| tx      | `string` |

### GraphQLClient.RequestGetAccountStateInput : `object`

Structure of GraphQLClient.RequestGetAccountStateInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type             |
| -------------- | ---------------- |
| address        | `string`         |
| keys           | `Array.<string>` |
| height         | `string`         |
| traceMigration | `boolean`        |

### GraphQLClient.RequestGetAccountTokensInput : `object`

Structure of GraphQLClient.RequestGetAccountTokensInput

Checkout the following snippet for the format of RequestGetAccountTokensInput:

```json
{
  "address": "abc",
  "token": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| token   | `string` |

### GraphQLClient.RequestGetBlockInput : `object`

Structure of GraphQLClient.RequestGetBlockInput

Checkout the following snippet for the format of RequestGetBlockInput:

```json
{}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type     |
| ------ | -------- |
| height | `string` |

### GraphQLClient.RequestGetBlocksInput : `object`

Structure of GraphQLClient.RequestGetBlocksInput

Checkout the following snippet for the format of RequestGetBlocksInput:

```json
{
  "emptyExcluded": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                  |
| --------------- | ----------------------------------------------------- |
| ...paging       | [`PageInput`](#GraphQLClient.PageInput)               |
| ...heightFilter | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| emptyExcluded   | `boolean`                                             |

### GraphQLClient.RequestGetConfigInput : `object`

Structure of GraphQLClient.RequestGetConfigInput

Checkout the following snippet for the format of RequestGetConfigInput:

```json
{
  "parsed": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type      |
| ------ | --------- |
| parsed | `boolean` |

### GraphQLClient.RequestGetEvidenceStateInput : `object`

Structure of GraphQLClient.RequestGetEvidenceStateInput

Checkout the following snippet for the format of RequestGetEvidenceStateInput:

```json
{
  "hash": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| hash | `string` |

### GraphQLClient.RequestGetRollupBlockInput : `object`

Structure of GraphQLClient.RequestGetRollupBlockInput

Checkout the following snippet for the format of RequestGetRollupBlockInput:

```json
{
  "hash": "abc",
  "rollupAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type     |
| ------------- | -------- |
| hash          | `string` |
| height        | `string` |
| rollupAddress | `string` |

### GraphQLClient.RequestGetStateInput : `object`

Structure of GraphQLClient.RequestGetStateInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| address | `string`         |
| keys    | `Array.<string>` |
| height  | `string`         |

### GraphQLClient.RequestGetTokenDistributionInput : `object`

Structure of GraphQLClient.RequestGetTokenDistributionInput

Checkout the following snippet for the format of RequestGetTokenDistributionInput:

```json
{
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type     |
| ------------ | -------- |
| tokenAddress | `string` |

### GraphQLClient.RequestGetTxInput : `object`

Structure of GraphQLClient.RequestGetTxInput

Checkout the following snippet for the format of RequestGetTxInput:

```json
{
  "hash": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| hash | `string` |

### GraphQLClient.RequestListAssetTransactionsInput : `object`

Structure of GraphQLClient.RequestListAssetTransactionsInput

Checkout the following snippet for the format of RequestListAssetTransactionsInput:

```json
{
  "address": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                    |
| --------- | --------------------------------------- |
| ...paging | [`PageInput`](#GraphQLClient.PageInput) |
| address   | `string`                                |

### GraphQLClient.RequestListAssetsInput : `object`

Structure of GraphQLClient.RequestListAssetsInput

Checkout the following snippet for the format of RequestListAssetsInput:

```json
{
  "ownerAddress": "abc",
  "factoryAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                |
| -------------- | --------------------------------------------------- |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput)             |
| ownerAddress   | `string`                                            |
| factoryAddress | `string`                                            |
| ...timeFilter  | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListBlocksInput : `object`

Structure of GraphQLClient.RequestListBlocksInput

Checkout the following snippet for the format of RequestListBlocksInput:

```json
{
  "proposer": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                   | Type                                                  |
| ---------------------- | ----------------------------------------------------- |
| ...paging              | [`PageInput`](#GraphQLClient.PageInput)               |
| proposer               | `string`                                              |
| ...timeFilter          | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)   |
| ...heightFilter        | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...numTxsFilter        | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...numInvalidTxsFilter | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |

### GraphQLClient.RequestListDelegationsInput : `object`

Structure of GraphQLClient.RequestListDelegationsInput

Checkout the following snippet for the format of RequestListDelegationsInput:

```json
{
  "from": "abc",
  "to": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| from          | `string`                                            |
| to            | `string`                                            |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListFactoriesInput : `object`

Structure of GraphQLClient.RequestListFactoriesInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| ownerAddress  | `string`                                            |
| addressList   | `Array.<string>`                                    |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListRollupBlocksInput : `object`

Structure of GraphQLClient.RequestListRollupBlocksInput

Checkout the following snippet for the format of RequestListRollupBlocksInput:

```json
{
  "rollupAddress": "abc",
  "tokenAddress": "abc",
  "proposer": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name               | Type                                                          |
| ------------------ | ------------------------------------------------------------- |
| ...paging          | [`PageInput`](#GraphQLClient.PageInput)                       |
| rollupAddress      | `string`                                                      |
| tokenAddress       | `string`                                                      |
| proposer           | `string`                                                      |
| ...validatorFilter | [`ValidatorFilterInput`](#GraphQLClient.ValidatorFilterInput) |
| ...txFilter        | [`TxFilterInput`](#GraphQLClient.TxFilterInput)               |
| ...timeFilter      | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)           |

### GraphQLClient.RequestListRollupValidatorsInput : `object`

Structure of GraphQLClient.RequestListRollupValidatorsInput

Checkout the following snippet for the format of RequestListRollupValidatorsInput:

```json
{
  "rollupAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                    |
| ------------- | --------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput) |
| rollupAddress | `string`                                |

### GraphQLClient.RequestListRollupsInput : `object`

Structure of GraphQLClient.RequestListRollupsInput

Checkout the following snippet for the format of RequestListRollupsInput:

```json
{
  "tokenAddress": "abc",
  "foreignTokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                                |
| ------------------- | --------------------------------------------------- |
| ...paging           | [`PageInput`](#GraphQLClient.PageInput)             |
| tokenAddress        | `string`                                            |
| foreignTokenAddress | `string`                                            |
| ...timeFilter       | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListStakesInput : `object`

Structure of GraphQLClient.RequestListStakesInput

Checkout the following snippet for the format of RequestListStakesInput:

```json
{}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                                      |
| ---------------- | --------------------------------------------------------- |
| ...paging        | [`PageInput`](#GraphQLClient.PageInput)                   |
| ...addressFilter | [`AddressFilterInput`](#GraphQLClient.AddressFilterInput) |
| ...timeFilter    | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)       |
| ...assetFilter   | [`AssetFilterInput`](#GraphQLClient.AssetFilterInput)     |

### GraphQLClient.RequestListTokenFactoriesInput : `object`

Structure of GraphQLClient.RequestListTokenFactoriesInput

Checkout the following snippet for the format of RequestListTokenFactoriesInput:

```json
{
  "owner": "abc",
  "reserveAddress": "abc",
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                |
| -------------- | --------------------------------------------------- |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput)             |
| owner          | `string`                                            |
| reserveAddress | `string`                                            |
| tokenAddress   | `string`                                            |
| ...timeFilter  | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListTokenFlowsInput : `object`

Structure of GraphQLClient.RequestListTokenFlowsInput

Checkout the following snippet for the format of RequestListTokenFlowsInput:

```json
{
  "accountAddress": "abc",
  "tokenAddress": "abc",
  "direction": "IN"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                    |
| -------------- | --------------------------------------- |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput) |
| accountAddress | `string`                                |
| tokenAddress   | `string`                                |
| depth          | `number`                                |
| ...direction   | `GraphQLClient.TokenFlowDirection`      |

### GraphQLClient.RequestListTokensInput : `object`

Structure of GraphQLClient.RequestListTokensInput

Checkout the following snippet for the format of RequestListTokensInput:

```json
{
  "issuerAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| issuerAddress | `string`                                            |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListTopAccountsInput : `object`

Structure of GraphQLClient.RequestListTopAccountsInput

Checkout the following snippet for the format of RequestListTopAccountsInput:

```json
{
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| tokenAddress  | `string`                                            |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.RequestListTransactionsInput : `object`

Structure of GraphQLClient.RequestListTransactionsInput

Checkout the following snippet for the format of RequestListTransactionsInput:

```json
{
  "includeData": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                                |
| --------------------- | ------------------------------------------------------------------- |
| ...paging             | [`PageInput`](#GraphQLClient.PageInput)                             |
| ...timeFilter         | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)                 |
| ...addressFilter      | [`AddressFilterInput`](#GraphQLClient.AddressFilterInput)           |
| ...typeFilter         | [`TypeFilterInput`](#GraphQLClient.TypeFilterInput)                 |
| ...validityFilter     | [`ValidityFilterInput`](#GraphQLClient.ValidityFilterInput)         |
| ...factoryFilter      | [`FactoryFilterInput`](#GraphQLClient.FactoryFilterInput)           |
| ...tokenFilter        | [`TokenFilterInput`](#GraphQLClient.TokenFilterInput)               |
| ...assetFilter        | [`AssetFilterInput`](#GraphQLClient.AssetFilterInput)               |
| ...accountFilter      | [`AccountFilterInput`](#GraphQLClient.AccountFilterInput)           |
| ...txFilter           | [`TxFilterInput`](#GraphQLClient.TxFilterInput)                     |
| ...rollupFilter       | [`RollupFilterInput`](#GraphQLClient.RollupFilterInput)             |
| ...stakeFilter        | [`StakeFilterInput`](#GraphQLClient.StakeFilterInput)               |
| ...delegationFilter   | [`DelegationFilterInput`](#GraphQLClient.DelegationFilterInput)     |
| ...tokenFactoryFilter | [`TokenFactoryFilterInput`](#GraphQLClient.TokenFactoryFilterInput) |
| includeData           | `boolean`                                                           |

### GraphQLClient.RequestSearchInput : `object`

Structure of GraphQLClient.RequestSearchInput

Checkout the following snippet for the format of RequestSearchInput:

```json
{
  "keyword": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                    |
| --------- | --------------------------------------- |
| ...paging | [`PageInput`](#GraphQLClient.PageInput) |
| keyword   | `string`                                |

### GraphQLClient.RequestSendTxInput : `object`

Structure of GraphQLClient.RequestSendTxInput

Checkout the following snippet for the format of RequestSendTxInput:

```json
{
  "tx": "abc",
  "token": "abc",
  "commit": true,
  "extra": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                                |
| --------- | --------------------------------------------------- |
| tx        | `string`                                            |
| ...wallet | [`WalletInfoInput`](#GraphQLClient.WalletInfoInput) |
| token     | `string`                                            |
| commit    | `boolean`                                           |
| extra     | `string`                                            |

### GraphQLClient.RequestVerifyAccountRiskInput : `object`

Structure of GraphQLClient.RequestVerifyAccountRiskInput

Checkout the following snippet for the format of RequestVerifyAccountRiskInput:

```json
{
  "accountAddress": "abc",
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type     |
| -------------- | -------- |
| accountAddress | `string` |
| tokenAddress   | `string` |

### GraphQLClient.RollupFilterInput : `object`

Structure of GraphQLClient.RollupFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| rollups | `Array.<string>` |

### GraphQLClient.StakeFilterInput : `object`

Structure of GraphQLClient.StakeFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type             |
| ------ | ---------------- |
| stakes | `Array.<string>` |

### GraphQLClient.TimeFilterInput : `object`

Structure of GraphQLClient.TimeFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type     |
| ------------- | -------- |
| startDateTime | `string` |
| endDateTime   | `string` |
| field         | `string` |

### GraphQLClient.TokenFactoryFilterInput : `object`

Structure of GraphQLClient.TokenFactoryFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type             |
| -------------- | ---------------- |
| tokenFactories | `Array.<string>` |

### GraphQLClient.TokenFilterInput : `object`

Structure of GraphQLClient.TokenFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type             |
| ------ | ---------------- |
| tokens | `Array.<string>` |

### GraphQLClient.TxFilterInput : `object`

Structure of GraphQLClient.TxFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type             |
| ---- | ---------------- |
| txs  | `Array.<string>` |

### GraphQLClient.TypeFilterInput : `object`

Structure of GraphQLClient.TypeFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type             |
| ----- | ---------------- |
| types | `Array.<string>` |

### GraphQLClient.ValidatorFilterInput : `object`

Structure of GraphQLClient.ValidatorFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type             |
| ---------- | ---------------- |
| validators | `Array.<string>` |

### GraphQLClient.ValidityFilterInput : `object`

Structure of GraphQLClient.ValidityFilterInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                     |
| ----------- | ------------------------ |
| ...validity | `GraphQLClient.Validity` |

### GraphQLClient.WalletInfoInput : `object`

Structure of GraphQLClient.WalletInfoInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                                |
| ------- | --------------------------------------------------- |
| ...type | [`WalletTypeInput`](#GraphQLClient.WalletTypeInput) |
| sk      | `string`                                            |
| pk      | `string`                                            |
| address | `string`                                            |

### GraphQLClient.WalletTypeInput : `object`

Structure of GraphQLClient.WalletTypeInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                         |
| ---------- | ---------------------------- |
| ...pk      | `GraphQLClient.KeyType`      |
| ...hash    | `GraphQLClient.HashType`     |
| ...address | `GraphQLClient.EncodingType` |
| ...role    | `GraphQLClient.RoleType`     |

### GraphQLClient.AccountConfig : `object`

Structure of GraphQLClient.AccountConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| pk      | `string` |
| balance | `string` |

### GraphQLClient.AccountMigrateTx : `object`

Structure of GraphQLClient.AccountMigrateTx

Checkout the following snippet for the format of AccountMigrateTx:

```json
{
  "pk": "abc",
  "type": {
    "pk": "ED25519",
    "hash": "KECCAK",
    "address": "BASE16",
    "role": "ROLE_ACCOUNT"
  },
  "address": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                      |
| ------- | ----------------------------------------- |
| pk      | `string`                                  |
| ...type | [`WalletType`](#GraphQLClient.WalletType) |
| address | `string`                                  |
| ...data | [`Any`](#GraphQLClient.Any)               |

### GraphQLClient.AccountState : `object`

Structure of GraphQLClient.AccountState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| balance      | `string`                                      |
| nonce        | `string`                                      |
| numTxs       | `string`                                      |
| address      | `string`                                      |
| pk           | `string`                                      |
| ...type      | [`WalletType`](#GraphQLClient.WalletType)     |
| moniker      | `string`                                      |
| ...context   | [`StateContext`](#GraphQLClient.StateContext) |
| issuer       | `string`                                      |
| gasBalance   | `string`                                      |
| migratedTo   | `Array.<string>`                              |
| migratedFrom | `Array.<string>`                              |
| numAssets    | `string`                                      |
| tokens       | `Array.<...GraphQLClient.IndexedTokenInput>`  |
| ...data      | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.AccountToken : `object`

Structure of GraphQLClient.AccountToken

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| symbol  | `string` |
| balance | `string` |
| decimal | `number` |

### GraphQLClient.AcquireAssetV2Tx : `object`

Structure of GraphQLClient.AcquireAssetV2Tx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                     |
| --------- | ---------------------------------------- |
| factory   | `string`                                 |
| address   | `string`                                 |
| assets    | `Array.<string>`                         |
| variables | `Array.<...GraphQLClient.VariableInput>` |
| ...issuer | [`NFTIssuer`](#GraphQLClient.NFTIssuer)  |
| ...data   | [`Any`](#GraphQLClient.Any)              |

### GraphQLClient.AcquireAssetV3Tx : `object`

Structure of GraphQLClient.AcquireAssetV3Tx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                        |
| --------- | ------------------------------------------- |
| factory   | `string`                                    |
| address   | `string`                                    |
| inputs    | `Array.<...GraphQLClient.TransactionInput>` |
| owner     | `string`                                    |
| variables | `Array.<...GraphQLClient.VariableInput>`    |
| ...issuer | [`NFTIssuer`](#GraphQLClient.NFTIssuer)     |
| ...data   | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.Any : `object`

Structure of GraphQLClient.Any

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| typeUrl | `string` |
| value   | `string` |

### GraphQLClient.AssetFactoryHook : `object`

Structure of GraphQLClient.AssetFactoryHook

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| name | `string` |
| type | `string` |
| hook | `string` |

### GraphQLClient.AssetFactoryInput : `object`

Structure of GraphQLClient.AssetFactoryInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                     |
| --------- | ---------------------------------------- |
| value     | `string`                                 |
| tokens    | `Array.<...GraphQLClient.TokenInput>`    |
| assets    | `Array.<string>`                         |
| variables | `Array.<...GraphQLClient.VariableInput>` |

### GraphQLClient.AssetFactoryState : `object`

Structure of GraphQLClient.AssetFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                        |
| -------------- | ----------------------------------------------------------- |
| address        | `string`                                                    |
| owner          | `string`                                                    |
| name           | `string`                                                    |
| description    | `string`                                                    |
| settlement     | `string`                                                    |
| limit          | `number`                                                    |
| trustedIssuers | `Array.<string>`                                            |
| ...input       | [`IndexedFactoryInput`](#GraphQLClient.IndexedFactoryInput) |
| ...output      | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx)             |
| hooks          | `Array.<...GraphQLClient.AssetFactoryHook>`                 |
| ...data        | [`Any`](#GraphQLClient.Any)                                 |
| ...context     | [`StateContext`](#GraphQLClient.StateContext)               |
| balance        | `string`                                                    |
| tokens         | `Array.<...GraphQLClient.IndexedTokenInput>`                |
| numMinted      | `number`                                                    |
| ...display     | [`NFTDisplay`](#GraphQLClient.NFTDisplay)                   |
| lastSettlement | `string`                                                    |

### GraphQLClient.AssetLimit : `object`

Structure of GraphQLClient.AssetLimit

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                    |
| ---------- | --------------------------------------- |
| address    | `Array.<string>`                        |
| to         | `Array.<string>`                        |
| txCount    | `number`                                |
| validUntil | `string`                                |
| ...rate    | [`RateLimit`](#GraphQLClient.RateLimit) |
| txSent     | `number`                                |
| lastTx     | `string`                                |

### GraphQLClient.AssetState : `object`

Structure of GraphQLClient.AssetState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                          |
| ------------- | --------------------------------------------- |
| address       | `string`                                      |
| owner         | `string`                                      |
| moniker       | `string`                                      |
| readonly      | `boolean`                                     |
| transferrable | `boolean`                                     |
| ttl           | `number`                                      |
| consumedTime  | `string`                                      |
| issuer        | `string`                                      |
| parent        | `string`                                      |
| ...endpoint   | [`NFTEndpoint`](#GraphQLClient.NFTEndpoint)   |
| ...display    | [`NFTDisplay`](#GraphQLClient.NFTDisplay)     |
| tags          | `Array.<string>`                              |
| ...context    | [`StateContext`](#GraphQLClient.StateContext) |
| ...data       | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.BlockID : `object`

Structure of GraphQLClient.BlockID

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                            |
| -------------- | ----------------------------------------------- |
| hash           | `string`                                        |
| ...partsHeader | [`PartSetHeader`](#GraphQLClient.PartSetHeader) |

### GraphQLClient.BlockInfo : `object`

Structure of GraphQLClient.BlockInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name               | Type                                       |
| ------------------ | ------------------------------------------ |
| height             | `string`                                   |
| numTxs             | `number`                                   |
| time               | `string`                                   |
| appHash            | `string`                                   |
| proposer           | `string`                                   |
| txs                | `Array.<...GraphQLClient.TransactionInfo>` |
| totalTxs           | `string`                                   |
| invalidTxs         | `Array.<...GraphQLClient.TransactionInfo>` |
| txsHashes          | `Array.<string>`                           |
| invalidTxsHashes   | `Array.<string>`                           |
| consensusHash      | `string`                                   |
| dataHash           | `string`                                   |
| evidenceHash       | `string`                                   |
| lastCommitHash     | `string`                                   |
| lastResultsHash    | `string`                                   |
| nextValidatorsHash | `string`                                   |
| validatorsHash     | `string`                                   |
| ...version         | [`Version`](#GraphQLClient.Version)        |
| ...lastBlockId     | [`BlockID`](#GraphQLClient.BlockID)        |

### GraphQLClient.BlockInfoSimple : `object`

Structure of GraphQLClient.BlockInfoSimple

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name               | Type                                |
| ------------------ | ----------------------------------- |
| height             | `string`                            |
| numTxs             | `number`                            |
| time               | `string`                            |
| appHash            | `string`                            |
| proposer           | `string`                            |
| totalTxs           | `string`                            |
| txsHashes          | `Array.<string>`                    |
| invalidTxsHashes   | `Array.<string>`                    |
| consensusHash      | `string`                            |
| dataHash           | `string`                            |
| evidenceHash       | `string`                            |
| lastCommitHash     | `string`                            |
| lastResultsHash    | `string`                            |
| nextValidatorsHash | `string`                            |
| validatorsHash     | `string`                            |
| ...version         | [`Version`](#GraphQLClient.Version) |
| ...lastBlockId     | [`BlockID`](#GraphQLClient.BlockID) |

### GraphQLClient.BurnTokenTx : `object`

Structure of GraphQLClient.BurnTokenTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                        |
| ------------ | ------------------------------------------- |
| tokenFactory | `string`                                    |
| inputs       | `Array.<...GraphQLClient.TransactionInput>` |
| minReserve   | `string`                                    |
| receiver     | `string`                                    |
| ...data      | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.ChainInfo : `object`

Structure of GraphQLClient.ChainInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type             |
| ---------------- | ---------------- |
| id               | `string`         |
| network          | `string`         |
| moniker          | `string`         |
| consensusVersion | `string`         |
| synced           | `boolean`        |
| appHash          | `string`         |
| blockHash        | `string`         |
| blockHeight      | `string`         |
| blockTime        | `string`         |
| address          | `string`         |
| votingPower      | `string`         |
| totalTxs         | `string`         |
| version          | `string`         |
| forgeAppsVersion | `object`         |
| supportedTxs     | `Array.<string>` |

### GraphQLClient.ClaimBlockRewardTx : `object`

Structure of GraphQLClient.ClaimBlockRewardTx

Checkout the following snippet for the format of ClaimBlockRewardTx:

```json
{
  "rollup": "abc",
  "blockHash": "abc",
  "evidence": {
    "hash": "abc"
  },
  "publisher": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                  |
| ----------- | ------------------------------------- |
| rollup      | `string`                              |
| blockHeight | `string`                              |
| blockHash   | `string`                              |
| ...evidence | [`Evidence`](#GraphQLClient.Evidence) |
| publisher   | `string`                              |
| ...data     | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.ClaimStakeTx : `object`

Structure of GraphQLClient.ClaimStakeTx

Checkout the following snippet for the format of ClaimStakeTx:

```json
{
  "address": "abc",
  "evidence": {
    "hash": "abc"
  },
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                  |
| ----------- | ------------------------------------- |
| address     | `string`                              |
| ...evidence | [`Evidence`](#GraphQLClient.Evidence) |
| ...data     | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.CloseRollupTx : `object`

Structure of GraphQLClient.CloseRollupTx

Checkout the following snippet for the format of CloseRollupTx:

```json
{
  "rollup": "abc",
  "message": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| rollup  | `string`                    |
| message | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.ConsensusParams : `object`

Structure of GraphQLClient.ConsensusParams

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                 |
| ---------------- | ------------------------------------ |
| maxBytes         | `string`                             |
| maxGas           | `string`                             |
| maxValidators    | `number`                             |
| maxCandidates    | `number`                             |
| pubKeyTypes      | `Array.<string>`                     |
| validators       | `Array.<...GraphQLClient.Validator>` |
| validatorChanged | `boolean`                            |
| paramChanged     | `boolean`                            |

### GraphQLClient.ConsumeAssetTx : `object`

Structure of GraphQLClient.ConsumeAssetTx

Checkout the following snippet for the format of ConsumeAssetTx:

```json
{
  "address": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| address | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.CreateAssetTx : `object`

Structure of GraphQLClient.CreateAssetTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                        |
| ------------- | ------------------------------------------- |
| moniker       | `string`                                    |
| ...data       | [`Any`](#GraphQLClient.Any)                 |
| readonly      | `boolean`                                   |
| transferrable | `boolean`                                   |
| ttl           | `number`                                    |
| parent        | `string`                                    |
| address       | `string`                                    |
| issuer        | `string`                                    |
| ...endpoint   | [`NFTEndpoint`](#GraphQLClient.NFTEndpoint) |
| ...display    | [`NFTDisplay`](#GraphQLClient.NFTDisplay)   |
| tags          | `Array.<string>`                            |

### GraphQLClient.CreateFactoryTx : `object`

Structure of GraphQLClient.CreateFactoryTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                    |
| -------------- | ------------------------------------------------------- |
| name           | `string`                                                |
| description    | `string`                                                |
| settlement     | `string`                                                |
| limit          | `number`                                                |
| trustedIssuers | `Array.<string>`                                        |
| ...input       | [`AssetFactoryInput`](#GraphQLClient.AssetFactoryInput) |
| ...output      | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx)         |
| hooks          | `Array.<...GraphQLClient.AssetFactoryHook>`             |
| address        | `string`                                                |
| ...display     | [`NFTDisplay`](#GraphQLClient.NFTDisplay)               |
| ...data        | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.CreateRollupBlockTx : `object`

Structure of GraphQLClient.CreateRollupBlockTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                |
| ------------ | ----------------------------------- |
| hash         | `string`                            |
| height       | `string`                            |
| merkleRoot   | `string`                            |
| previousHash | `string`                            |
| txsHash      | `string`                            |
| txs          | `Array.<string>`                    |
| proposer     | `string`                            |
| signatures   | `Array.<...GraphQLClient.Multisig>` |
| rollup       | `string`                            |
| minReward    | `string`                            |
| governance   | `boolean`                           |
| ...data      | [`Any`](#GraphQLClient.Any)         |

### GraphQLClient.CreateRollupTx : `object`

Structure of GraphQLClient.CreateRollupTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                 | Type                                       |
| -------------------- | ------------------------------------------ |
| address              | `string`                                   |
| tokenAddress         | `string`                                   |
| vaultAddress         | `string`                                   |
| contractAddress      | `string`                                   |
| seedValidators       | `Array.<...GraphQLClient.RollupValidator>` |
| minStakeAmount       | `string`                                   |
| maxStakeAmount       | `string`                                   |
| minSignerCount       | `number`                                   |
| maxSignerCount       | `number`                                   |
| minBlockSize         | `number`                                   |
| maxBlockSize         | `number`                                   |
| minBlockInterval     | `number`                                   |
| minBlockConfirmation | `number`                                   |
| foreignChainType     | `string`                                   |
| foreignChainId       | `string`                                   |
| depositFeeRate       | `number`                                   |
| withdrawFeeRate      | `number`                                   |
| proposerFeeShare     | `number`                                   |
| minDepositAmount     | `string`                                   |
| minWithdrawAmount    | `string`                                   |
| maxDepositAmount     | `string`                                   |
| maxWithdrawAmount    | `string`                                   |
| minDepositFee        | `string`                                   |
| maxDepositFee        | `string`                                   |
| minWithdrawFee       | `string`                                   |
| maxWithdrawFee       | `string`                                   |
| paused               | `boolean`                                  |
| leaveWaitingPeriod   | `number`                                   |
| publisherFeeShare    | `number`                                   |
| publishWaitingPeriod | `number`                                   |
| publishSlashRate     | `number`                                   |
| ...data              | [`Any`](#GraphQLClient.Any)                |

### GraphQLClient.CreateTokenFactoryTx : `object`

Structure of GraphQLClient.CreateTokenFactoryTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                        |
| -------------- | ------------------------------------------- |
| address        | `string`                                    |
| feeRate        | `number`                                    |
| ...token       | [`TokenInfo`](#GraphQLClient.TokenInfo)     |
| reserveAddress | `string`                                    |
| ...curve       | [`CurveConfig`](#GraphQLClient.CurveConfig) |
| ...data        | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.CreateTokenTx : `object`

Structure of GraphQLClient.CreateTokenTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                          |
| --------------- | --------------------------------------------- |
| name            | `string`                                      |
| description     | `string`                                      |
| symbol          | `string`                                      |
| unit            | `string`                                      |
| decimal         | `number`                                      |
| icon            | `string`                                      |
| totalSupply     | `string`                                      |
| address         | `string`                                      |
| initialSupply   | `string`                                      |
| maxTotalSupply  | `string`                                      |
| ...foreignToken | [`ForeignToken`](#GraphQLClient.ForeignToken) |
| spenders        | `Array.<string>`                              |
| ...data         | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.CurveConfig : `object`

Structure of GraphQLClient.CurveConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type     |
| ---------- | -------- |
| type       | `string` |
| basePrice  | `string` |
| slope      | `string` |
| fixedPrice | `string` |
| constant   | `number` |

### GraphQLClient.DeclareTx : `object`

Structure of GraphQLClient.DeclareTx

Checkout the following snippet for the format of DeclareTx:

```json
{
  "moniker": "abc",
  "issuer": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| moniker | `string`                    |
| issuer  | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.DelegateConfig : `object`

Structure of GraphQLClient.DelegateConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type             |
| ------------- | ---------------- |
| deltaInterval | `number`         |
| typeUrls      | `Array.<string>` |

### GraphQLClient.DelegateLimit : `object`

Structure of GraphQLClient.DelegateLimit

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type                                  |
| ------ | ------------------------------------- |
| tokens | `Array.<...GraphQLClient.TokenLimit>` |
| assets | `Array.<...GraphQLClient.AssetLimit>` |

### GraphQLClient.DelegateOp : `object`

Structure of GraphQLClient.DelegateOp

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                            |
| -------- | ----------------------------------------------- |
| typeUrl  | `string`                                        |
| rules    | `Array.<string>`                                |
| ...limit | [`DelegateLimit`](#GraphQLClient.DelegateLimit) |

### GraphQLClient.DelegateOpState : `object`

Structure of GraphQLClient.DelegateOpState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                            |
| ------------ | ----------------------------------------------- |
| rule         | `string`                                        |
| numTxs       | `string`                                        |
| numTxsDelta  | `string`                                        |
| balance      | `string`                                        |
| balanceDelta | `string`                                        |
| ...limit     | [`DelegateLimit`](#GraphQLClient.DelegateLimit) |

### GraphQLClient.DelegateState : `object`

Structure of GraphQLClient.DelegateState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                          |
| ---------- | --------------------------------------------- |
| address    | `string`                                      |
| ops        | `object`                                      |
| from       | `string`                                      |
| to         | `string`                                      |
| deny       | `Array.<string>`                              |
| validUntil | `string`                                      |
| ...context | [`StateContext`](#GraphQLClient.StateContext) |
| ...data    | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.DelegateTx : `object`

Structure of GraphQLClient.DelegateTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                  |
| ---------- | ------------------------------------- |
| address    | `string`                              |
| to         | `string`                              |
| ops        | `Array.<...GraphQLClient.DelegateOp>` |
| deny       | `Array.<string>`                      |
| validUntil | `string`                              |
| ...data    | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.DepositTokenV2Tx : `object`

Structure of GraphQLClient.DepositTokenV2Tx

Checkout the following snippet for the format of DepositTokenV2Tx:

```json
{
  "token": {
    "address": "abc",
    "value": "abc"
  },
  "to": "abc",
  "proposer": "abc",
  "evidence": {
    "hash": "abc"
  },
  "rollup": "abc",
  "actualFee": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                      |
| ----------- | ----------------------------------------- |
| ...token    | [`TokenInput`](#GraphQLClient.TokenInput) |
| to          | `string`                                  |
| proposer    | `string`                                  |
| ...evidence | [`Evidence`](#GraphQLClient.Evidence)     |
| rollup      | `string`                                  |
| actualFee   | `string`                                  |
| ...data     | [`Any`](#GraphQLClient.Any)               |

### GraphQLClient.Evidence : `object`

Structure of GraphQLClient.Evidence

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| hash | `string` |

### GraphQLClient.EvidenceState : `object`

Structure of GraphQLClient.EvidenceState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                          |
| ---------- | --------------------------------------------- |
| hash       | `string`                                      |
| data       | `string`                                      |
| ...context | [`StateContext`](#GraphQLClient.StateContext) |

### GraphQLClient.ExchangeInfo : `object`

Structure of GraphQLClient.ExchangeInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type             |
| ------ | ---------------- |
| value  | `string`         |
| assets | `Array.<string>` |

### GraphQLClient.ExchangeInfoV2 : `object`

Structure of GraphQLClient.ExchangeInfoV2

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type                                  |
| ------ | ------------------------------------- |
| value  | `string`                              |
| assets | `Array.<string>`                      |
| tokens | `Array.<...GraphQLClient.TokenInput>` |

### GraphQLClient.ExchangeTx : `object`

Structure of GraphQLClient.ExchangeTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                          |
| ----------- | --------------------------------------------- |
| to          | `string`                                      |
| ...sender   | [`ExchangeInfo`](#GraphQLClient.ExchangeInfo) |
| ...receiver | [`ExchangeInfo`](#GraphQLClient.ExchangeInfo) |
| expiredAt   | `string`                                      |
| ...data     | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.ExchangeV2Tx : `object`

Structure of GraphQLClient.ExchangeV2Tx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                              |
| ----------- | ------------------------------------------------- |
| to          | `string`                                          |
| ...sender   | [`ExchangeInfoV2`](#GraphQLClient.ExchangeInfoV2) |
| ...receiver | [`ExchangeInfoV2`](#GraphQLClient.ExchangeInfoV2) |
| expiredAt   | `string`                                          |
| ...data     | [`Any`](#GraphQLClient.Any)                       |

### GraphQLClient.ForeignToken : `object`

Structure of GraphQLClient.ForeignToken

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type     |
| --------------- | -------- |
| type            | `string` |
| contractAddress | `string` |
| chainType       | `string` |
| chainName       | `string` |
| chainId         | `number` |

### GraphQLClient.ForgeState : `object`

Structure of GraphQLClient.ForgeState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                    |
| --------------- | ------------------------------------------------------- |
| address         | `string`                                                |
| ...consensus    | [`ConsensusParams`](#GraphQLClient.ConsensusParams)     |
| tasks           | `object`                                                |
| version         | `string`                                                |
| ...token        | [`ForgeToken`](#GraphQLClient.ForgeToken)               |
| ...txConfig     | [`TransactionConfig`](#GraphQLClient.TransactionConfig) |
| ...upgradeInfo  | [`UpgradeInfo`](#GraphQLClient.UpgradeInfo)             |
| accountConfig   | `Array.<...GraphQLClient.AccountConfig>`                |
| ...vaults       | [`VaultConfig`](#GraphQLClient.VaultConfig)             |
| reservedSymbols | `Array.<string>`                                        |
| ...data         | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.ForgeStats : `object`

Structure of GraphQLClient.ForgeStats

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                   | Type             |
| ---------------------- | ---------------- |
| numBlocks              | `Array.<string>` |
| numTxs                 | `Array.<string>` |
| numStakes              | `Array.<string>` |
| numValidators          | `Array.<number>` |
| numAccountMigrateTxs   | `Array.<string>` |
| numCreateAssetTxs      | `Array.<string>` |
| numConsensusUpgradeTxs | `Array.<number>` |
| numDeclareTxs          | `Array.<string>` |
| numDeclareFileTxs      | `Array.<string>` |
| numExchangeTxs         | `Array.<string>` |
| numStakeTxs            | `Array.<string>` |
| numSysUpgradeTxs       | `Array.<number>` |
| numTransferTxs         | `Array.<string>` |
| numUpdateAssetTxs      | `Array.<string>` |
| numConsumeAssetTxs     | `Array.<string>` |
| tps                    | `Array.<number>` |
| maxTps                 | `number`         |
| avgTps                 | `number`         |
| avgBlockTime           | `number`         |

### GraphQLClient.ForgeToken : `object`

Structure of GraphQLClient.ForgeToken

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type     |
| ------------- | -------- |
| name          | `string` |
| symbol        | `string` |
| unit          | `string` |
| description   | `string` |
| icon          | `string` |
| decimal       | `number` |
| initialSupply | `string` |
| totalSupply   | `string` |
| inflationRate | `number` |
| address       | `string` |

### GraphQLClient.GasEstimate : `object`

Structure of GraphQLClient.GasEstimate

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| max  | `string` |

### GraphQLClient.GeoInfo : `object`

Structure of GraphQLClient.GeoInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type     |
| --------- | -------- |
| city      | `string` |
| country   | `string` |
| latitude  | `number` |
| longitude | `number` |

### GraphQLClient.IndexedAccountState : `object`

Structure of GraphQLClient.IndexedAccountState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                 |
| ------------------- | ------------------------------------ |
| address             | `string`                             |
| balance             | `string`                             |
| numAssets           | `string`                             |
| numTxs              | `string`                             |
| nonce               | `string`                             |
| genesisTime         | `string`                             |
| renaissanceTime     | `string`                             |
| moniker             | `string`                             |
| migratedFrom        | `string`                             |
| migratedTo          | `string`                             |
| totalReceivedStakes | `string`                             |
| totalStakes         | `string`                             |
| totalUnstakes       | `string`                             |
| recentNumTxs        | `Array.<string>`                     |
| tokens              | `Array.<...GraphQLClient.TokenMeta>` |

### GraphQLClient.IndexedAssetState : `object`

Structure of GraphQLClient.IndexedAssetState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                        |
| --------------- | ------------------------------------------- |
| address         | `string`                                    |
| owner           | `string`                                    |
| genesisTime     | `string`                                    |
| renaissanceTime | `string`                                    |
| moniker         | `string`                                    |
| readonly        | `boolean`                                   |
| consumedTime    | `string`                                    |
| issuer          | `string`                                    |
| parent          | `string`                                    |
| transferrable   | `boolean`                                   |
| ttl             | `string`                                    |
| ...display      | [`NFTDisplay`](#GraphQLClient.NFTDisplay)   |
| ...endpoint     | [`NFTEndpoint`](#GraphQLClient.NFTEndpoint) |
| tags            | `Array.<string>`                            |
| ...data         | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.IndexedBlock : `object`

Structure of GraphQLClient.IndexedBlock

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type     |
| ------------- | -------- |
| height        | `string` |
| time          | `string` |
| proposer      | `string` |
| numTxs        | `string` |
| numInvalidTxs | `string` |

### GraphQLClient.IndexedDelegationState : `object`

Structure of GraphQLClient.IndexedDelegationState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                        |
| --------------- | --------------------------- |
| address         | `string`                    |
| from            | `string`                    |
| to              | `string`                    |
| genesisTime     | `string`                    |
| renaissanceTime | `string`                    |
| ops             | `object`                    |
| ...data         | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.IndexedFactoryInput : `object`

Structure of GraphQLClient.IndexedFactoryInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                         |
| --------- | -------------------------------------------- |
| value     | `string`                                     |
| tokens    | `Array.<...GraphQLClient.IndexedTokenInput>` |
| assets    | `Array.<string>`                             |
| variables | `Array.<...GraphQLClient.VariableInput>`     |

### GraphQLClient.IndexedFactoryState : `object`

Structure of GraphQLClient.IndexedFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                        |
| --------------- | ----------------------------------------------------------- |
| address         | `string`                                                    |
| owner           | `string`                                                    |
| name            | `string`                                                    |
| description     | `string`                                                    |
| settlement      | `string`                                                    |
| limit           | `string`                                                    |
| trustedIssuers  | `Array.<string>`                                            |
| ...input        | [`IndexedFactoryInput`](#GraphQLClient.IndexedFactoryInput) |
| ...output       | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx)             |
| hooks           | `Array.<...GraphQLClient.AssetFactoryHook>`                 |
| ...data         | [`Any`](#GraphQLClient.Any)                                 |
| balance         | `string`                                                    |
| tokens          | `Array.<...GraphQLClient.TokenMeta>`                        |
| numMinted       | `number`                                                    |
| lastSettlement  | `string`                                                    |
| genesisTime     | `string`                                                    |
| renaissanceTime | `string`                                                    |
| ...display      | [`NFTDisplay`](#GraphQLClient.NFTDisplay)                   |

### GraphQLClient.IndexedRollupBlock : `object`

Structure of GraphQLClient.IndexedRollupBlock

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                    |
| --------------- | ------------------------------------------------------- |
| hash            | `string`                                                |
| height          | `string`                                                |
| merkleRoot      | `string`                                                |
| previousHash    | `string`                                                |
| txsHash         | `string`                                                |
| txs             | `Array.<string>`                                        |
| proposer        | `string`                                                |
| signatures      | `Array.<...GraphQLClient.Multisig>`                     |
| genesisTime     | `string`                                                |
| renaissanceTime | `string`                                                |
| rollup          | `string`                                                |
| mintedAmount    | `string`                                                |
| burnedAmount    | `string`                                                |
| rewardAmount    | `string`                                                |
| governance      | `boolean`                                               |
| ...tokenInfo    | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
| ...data         | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.IndexedRollupState : `object`

Structure of GraphQLClient.IndexedRollupState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                 | Type                                                    |
| -------------------- | ------------------------------------------------------- |
| address              | `string`                                                |
| tokenAddress         | `string`                                                |
| vaultAddress         | `string`                                                |
| contractAddress      | `string`                                                |
| seedValidators       | `Array.<...GraphQLClient.RollupValidator>`              |
| validators           | `Array.<...GraphQLClient.RollupValidator>`              |
| minStakeAmount       | `string`                                                |
| maxStakeAmount       | `string`                                                |
| minSignerCount       | `number`                                                |
| maxSignerCount       | `number`                                                |
| minBlockSize         | `number`                                                |
| maxBlockSize         | `number`                                                |
| minBlockInterval     | `number`                                                |
| genesisTime          | `string`                                                |
| renaissanceTime      | `string`                                                |
| ...tokenInfo         | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
| issuer               | `string`                                                |
| depositFeeRate       | `number`                                                |
| withdrawFeeRate      | `number`                                                |
| proposerFeeShare     | `number`                                                |
| minDepositAmount     | `string`                                                |
| minWithdrawAmount    | `string`                                                |
| blockHeight          | `string`                                                |
| blockHash            | `string`                                                |
| minBlockConfirmation | `number`                                                |
| totalDepositAmount   | `string`                                                |
| totalWithdrawAmount  | `string`                                                |
| maxDepositAmount     | `string`                                                |
| maxWithdrawAmount    | `string`                                                |
| minDepositFee        | `string`                                                |
| maxDepositFee        | `string`                                                |
| minWithdrawFee       | `string`                                                |
| maxWithdrawFee       | `string`                                                |
| paused               | `boolean`                                               |
| ...foreignToken      | [`ForeignToken`](#GraphQLClient.ForeignToken)           |
| leaveWaitingPeriod   | `number`                                                |
| publisherFeeShare    | `number`                                                |
| publishWaitingPeriod | `number`                                                |
| publishSlashRate     | `number`                                                |
| migrateHistory       | `Array.<string>`                                        |
| closed               | `boolean`                                               |
| vaultHistory         | `Array.<string>`                                        |
| ...data              | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.IndexedRollupValidator : `object`

Structure of GraphQLClient.IndexedRollupValidator

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name               | Type     |
| ------------------ | -------- |
| pk                 | `string` |
| address            | `string` |
| moniker            | `string` |
| endpoint           | `string` |
| joinTime           | `string` |
| leaveTime          | `string` |
| genesisTime        | `string` |
| renaissanceTime    | `string` |
| totalStake         | `string` |
| revokedStake       | `string` |
| availableStake     | `string` |
| totalGain          | `string` |
| proposedBlockCount | `string` |
| verifiedBlockCount | `string` |
| latestBlockHeight  | `string` |
| latestBlockHash    | `string` |
| rollup             | `string` |

### GraphQLClient.IndexedStakeState : `object`

Structure of GraphQLClient.IndexedStakeState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                 |
| ------------------- | ------------------------------------ |
| address             | `string`                             |
| sender              | `string`                             |
| receiver            | `string`                             |
| tokens              | `Array.<...GraphQLClient.TokenMeta>` |
| assets              | `Array.<string>`                     |
| revocable           | `boolean`                            |
| genesisTime         | `string`                             |
| renaissanceTime     | `string`                             |
| message             | `string`                             |
| revokeWaitingPeriod | `number`                             |
| revokedTokens       | `Array.<...GraphQLClient.TokenMeta>` |
| revokedAssets       | `Array.<string>`                     |
| slashers            | `Array.<string>`                     |
| nonce               | `string`                             |
| ...data             | [`Any`](#GraphQLClient.Any)          |

### GraphQLClient.IndexedTokenFactoryState : `object`

Structure of GraphQLClient.IndexedTokenFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                    |
| --------------- | ------------------------------------------------------- |
| address         | `string`                                                |
| owner           | `string`                                                |
| tokenAddress    | `string`                                                |
| reserveAddress  | `string`                                                |
| ...curve        | [`CurveConfig`](#GraphQLClient.CurveConfig)             |
| feeRate         | `number`                                                |
| currentSupply   | `string`                                                |
| reserveBalance  | `string`                                                |
| status          | `string`                                                |
| genesisTime     | `string`                                                |
| renaissanceTime | `string`                                                |
| ...token        | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
| ...reserveToken | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
| ...data         | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.IndexedTokenFlow : `object`

Structure of GraphQLClient.IndexedTokenFlow

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| value | `string` |
| hash  | `string` |
| from  | `string` |
| to    | `string` |

### GraphQLClient.IndexedTokenInput : `object`

Structure of GraphQLClient.IndexedTokenInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| value   | `string` |
| decimal | `number` |
| unit    | `string` |
| symbol  | `string` |

### GraphQLClient.IndexedTokenState : `object`

Structure of GraphQLClient.IndexedTokenState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                          |
| ------------------- | --------------------------------------------- |
| name                | `string`                                      |
| description         | `string`                                      |
| symbol              | `string`                                      |
| unit                | `string`                                      |
| decimal             | `number`                                      |
| issuer              | `string`                                      |
| icon                | `string`                                      |
| totalSupply         | `string`                                      |
| address             | `string`                                      |
| genesisTime         | `string`                                      |
| renaissanceTime     | `string`                                      |
| ...foreignToken     | [`ForeignToken`](#GraphQLClient.ForeignToken) |
| tokenFactoryAddress | `string`                                      |
| maxTotalSupply      | `string`                                      |
| initialSupply       | `string`                                      |
| ...metadata         | [`Any`](#GraphQLClient.Any)                   |
| website             | `string`                                      |
| spenders            | `Array.<string>`                              |
| minters             | `Array.<string>`                              |
| type                | `string`                                      |
| ...data             | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.IndexedTransaction : `object`

Structure of GraphQLClient.IndexedTransaction

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| hash         | `string`                                      |
| sender       | `string`                                      |
| receiver     | `string`                                      |
| time         | `string`                                      |
| type         | `string`                                      |
| ...tx        | [`Transaction`](#GraphQLClient.Transaction)   |
| valid        | `boolean`                                     |
| code         | `string`                                      |
| tokenSymbols | `Array.<...GraphQLClient.TokenMeta>`          |
| receipts     | `Array.<...GraphQLClient.TransactionReceipt>` |

### GraphQLClient.JoinRollupTx : `object`

Structure of GraphQLClient.JoinRollupTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                  |
| ----------- | ------------------------------------- |
| rollup      | `string`                              |
| endpoint    | `string`                              |
| ...evidence | [`Evidence`](#GraphQLClient.Evidence) |
| signatures  | `Array.<...GraphQLClient.Multisig>`   |
| ...data     | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.KVPair : `object`

Structure of GraphQLClient.KVPair

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| key   | `string` |
| value | `string` |

### GraphQLClient.LeaveRollupTx : `object`

Structure of GraphQLClient.LeaveRollupTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                  |
| ----------- | ------------------------------------- |
| rollup      | `string`                              |
| ...evidence | [`Evidence`](#GraphQLClient.Evidence) |
| signatures  | `Array.<...GraphQLClient.Multisig>`   |
| ...data     | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.MigrateRollupTx : `object`

Structure of GraphQLClient.MigrateRollupTx

Checkout the following snippet for the format of MigrateRollupTx:

```json
{
  "rollup": "abc",
  "to": "abc",
  "type": "abc",
  "message": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| rollup  | `string`                    |
| to      | `string`                    |
| type    | `string`                    |
| message | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.MintAssetTx : `object`

Structure of GraphQLClient.MintAssetTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                     |
| --------- | ---------------------------------------- |
| factory   | `string`                                 |
| address   | `string`                                 |
| assets    | `Array.<string>`                         |
| variables | `Array.<...GraphQLClient.VariableInput>` |
| owner     | `string`                                 |
| ...data   | [`Any`](#GraphQLClient.Any)              |

### GraphQLClient.MintTokenTx : `object`

Structure of GraphQLClient.MintTokenTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                        |
| ------------ | ------------------------------------------- |
| tokenFactory | `string`                                    |
| amount       | `string`                                    |
| inputs       | `Array.<...GraphQLClient.TransactionInput>` |
| receiver     | `string`                                    |
| ...data      | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.Multisig : `object`

Structure of GraphQLClient.Multisig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                        |
| --------- | --------------------------- |
| signer    | `string`                    |
| pk        | `string`                    |
| signature | `string`                    |
| delegator | `string`                    |
| ...data   | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.NFTDisplay : `object`

Structure of GraphQLClient.NFTDisplay

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| type    | `string` |
| content | `string` |

### GraphQLClient.NFTEndpoint : `object`

Structure of GraphQLClient.NFTEndpoint

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| id    | `string` |
| scope | `string` |

### GraphQLClient.NFTIssuer : `object`

Structure of GraphQLClient.NFTIssuer

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| id   | `string` |
| pk   | `string` |
| name | `string` |

### GraphQLClient.NetInfo : `object`

Structure of GraphQLClient.NetInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                |
| --------- | ----------------------------------- |
| listening | `boolean`                           |
| listeners | `Array.<string>`                    |
| nPeers    | `number`                            |
| peers     | `Array.<...GraphQLClient.PeerInfo>` |

### GraphQLClient.NodeInfo : `object`

Structure of GraphQLClient.NodeInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                |
| ---------------- | ----------------------------------- |
| id               | `string`                            |
| network          | `string`                            |
| moniker          | `string`                            |
| consensusVersion | `string`                            |
| synced           | `boolean`                           |
| appHash          | `string`                            |
| blockHash        | `string`                            |
| blockHeight      | `string`                            |
| blockTime        | `string`                            |
| address          | `string`                            |
| votingPower      | `string`                            |
| totalTxs         | `string`                            |
| version          | `string`                            |
| forgeAppsVersion | `object`                            |
| supportedTxs     | `Array.<string>`                    |
| ip               | `string`                            |
| ...geoInfo       | [`GeoInfo`](#GraphQLClient.GeoInfo) |
| p2pAddress       | `string`                            |

### GraphQLClient.PageInfo : `object`

Structure of GraphQLClient.PageInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type      |
| ------ | --------- |
| cursor | `string`  |
| next   | `boolean` |
| total  | `number`  |

### GraphQLClient.PartSetHeader : `object`

Structure of GraphQLClient.PartSetHeader

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| total | `number` |
| hash  | `string` |

### GraphQLClient.PauseRollupTx : `object`

Structure of GraphQLClient.PauseRollupTx

Checkout the following snippet for the format of PauseRollupTx:

```json
{
  "rollup": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| rollup  | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.PeerInfo : `object`

Structure of GraphQLClient.PeerInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                |
| ---------------- | ----------------------------------- |
| id               | `string`                            |
| network          | `string`                            |
| consensusVersion | `string`                            |
| moniker          | `string`                            |
| ip               | `string`                            |
| ...geoInfo       | [`GeoInfo`](#GraphQLClient.GeoInfo) |

### GraphQLClient.PubKey : `object`

Structure of GraphQLClient.PubKey

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| type | `string` |
| data | `string` |

### GraphQLClient.RateLimit : `object`

Structure of GraphQLClient.RateLimit

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type     |
| -------- | -------- |
| interval | `string` |
| anchor   | `string` |

### GraphQLClient.ReceiptChange : `object`

Structure of GraphQLClient.ReceiptChange

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type     |
| ------ | -------- |
| target | `string` |
| action | `string` |
| value  | `string` |

### GraphQLClient.ResponseEstimateGas : `object`

Structure of GraphQLClient.ResponseEstimateGas

Checkout the following snippet for the format of ResponseEstimateGas:

```json
{
  "code": "abc",
  "estimate": {
    "max": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                        |
| ----------- | ------------------------------------------- |
| code        | `string`                                    |
| ...estimate | [`GasEstimate`](#GraphQLClient.GasEstimate) |

### GraphQLClient.ResponseGetAccountState : `object`

Structure of GraphQLClient.ResponseGetAccountState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                          |
| -------- | --------------------------------------------- |
| code     | `string`                                      |
| ...state | [`AccountState`](#GraphQLClient.AccountState) |

### GraphQLClient.ResponseGetAccountTokens : `object`

Structure of GraphQLClient.ResponseGetAccountTokens

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type                                    |
| ------ | --------------------------------------- |
| code   | `string`                                |
| tokens | `Array.<...GraphQLClient.AccountToken>` |

### GraphQLClient.ResponseGetAssetState : `object`

Structure of GraphQLClient.ResponseGetAssetState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                      |
| -------- | ----------------------------------------- |
| code     | `string`                                  |
| ...state | [`AssetState`](#GraphQLClient.AssetState) |

### GraphQLClient.ResponseGetBlock : `object`

Structure of GraphQLClient.ResponseGetBlock

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                    |
| -------- | --------------------------------------- |
| code     | `string`                                |
| ...block | [`BlockInfo`](#GraphQLClient.BlockInfo) |

### GraphQLClient.ResponseGetBlocks : `object`

Structure of GraphQLClient.ResponseGetBlocks

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                       |
| ------- | ------------------------------------------ |
| code    | `string`                                   |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)      |
| blocks  | `Array.<...GraphQLClient.BlockInfoSimple>` |

### GraphQLClient.ResponseGetChainInfo : `object`

Structure of GraphQLClient.ResponseGetChainInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                    |
| ------- | --------------------------------------- |
| code    | `string`                                |
| ...info | [`ChainInfo`](#GraphQLClient.ChainInfo) |

### GraphQLClient.ResponseGetConfig : `object`

Structure of GraphQLClient.ResponseGetConfig

Checkout the following snippet for the format of ResponseGetConfig:

```json
{
  "code": "abc",
  "config": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type     |
| ------ | -------- |
| code   | `string` |
| config | `string` |

### GraphQLClient.ResponseGetDelegateState : `object`

Structure of GraphQLClient.ResponseGetDelegateState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                            |
| -------- | ----------------------------------------------- |
| code     | `string`                                        |
| ...state | [`DelegateState`](#GraphQLClient.DelegateState) |

### GraphQLClient.ResponseGetEvidenceState : `object`

Structure of GraphQLClient.ResponseGetEvidenceState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                            |
| -------- | ----------------------------------------------- |
| code     | `string`                                        |
| ...state | [`EvidenceState`](#GraphQLClient.EvidenceState) |

### GraphQLClient.ResponseGetFactoryState : `object`

Structure of GraphQLClient.ResponseGetFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                                    |
| -------- | ------------------------------------------------------- |
| code     | `string`                                                |
| ...state | [`AssetFactoryState`](#GraphQLClient.AssetFactoryState) |

### GraphQLClient.ResponseGetForgeState : `object`

Structure of GraphQLClient.ResponseGetForgeState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                      |
| -------- | ----------------------------------------- |
| code     | `string`                                  |
| ...state | [`ForgeState`](#GraphQLClient.ForgeState) |

### GraphQLClient.ResponseGetForgeStats : `object`

Structure of GraphQLClient.ResponseGetForgeStats

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                      |
| ------------- | ----------------------------------------- |
| code          | `string`                                  |
| ...forgeStats | [`ForgeStats`](#GraphQLClient.ForgeStats) |

### GraphQLClient.ResponseGetNetInfo : `object`

Structure of GraphQLClient.ResponseGetNetInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                |
| ---------- | ----------------------------------- |
| code       | `string`                            |
| ...netInfo | [`NetInfo`](#GraphQLClient.NetInfo) |

### GraphQLClient.ResponseGetNodeInfo : `object`

Structure of GraphQLClient.ResponseGetNodeInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                  |
| ------- | ------------------------------------- |
| code    | `string`                              |
| ...info | [`NodeInfo`](#GraphQLClient.NodeInfo) |

### GraphQLClient.ResponseGetRollupBlock : `object`

Structure of GraphQLClient.ResponseGetRollupBlock

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                        |
| -------- | ------------------------------------------- |
| code     | `string`                                    |
| ...block | [`RollupBlock`](#GraphQLClient.RollupBlock) |

### GraphQLClient.ResponseGetRollupState : `object`

Structure of GraphQLClient.ResponseGetRollupState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                        |
| -------- | ------------------------------------------- |
| code     | `string`                                    |
| ...state | [`RollupState`](#GraphQLClient.RollupState) |

### GraphQLClient.ResponseGetStakeState : `object`

Structure of GraphQLClient.ResponseGetStakeState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                      |
| -------- | ----------------------------------------- |
| code     | `string`                                  |
| ...state | [`StakeState`](#GraphQLClient.StakeState) |

### GraphQLClient.ResponseGetTokenDistribution : `object`

Structure of GraphQLClient.ResponseGetTokenDistribution

Checkout the following snippet for the format of ResponseGetTokenDistribution:

```json
{
  "code": "abc",
  "data": {
    "tokenAddress": "abc",
    "txTime": "abc",
    "account": "abc",
    "gas": "abc",
    "fee": "abc",
    "slashedVault": "abc",
    "stake": "abc",
    "revokedStake": "abc",
    "gasStake": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                                    |
| ------- | ------------------------------------------------------- |
| code    | `string`                                                |
| ...data | [`TokenDistribution`](#GraphQLClient.TokenDistribution) |

### GraphQLClient.ResponseGetTokenFactoryState : `object`

Structure of GraphQLClient.ResponseGetTokenFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                                    |
| -------- | ------------------------------------------------------- |
| code     | `string`                                                |
| ...state | [`TokenFactoryState`](#GraphQLClient.TokenFactoryState) |

### GraphQLClient.ResponseGetTokenState : `object`

Structure of GraphQLClient.ResponseGetTokenState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                      |
| -------- | ----------------------------------------- |
| code     | `string`                                  |
| ...state | [`TokenState`](#GraphQLClient.TokenState) |

### GraphQLClient.ResponseGetTx : `object`

Structure of GraphQLClient.ResponseGetTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                                |
| ------- | --------------------------------------------------- |
| code    | `string`                                            |
| ...info | [`TransactionInfo`](#GraphQLClient.TransactionInfo) |

### GraphQLClient.ResponseGetUnconfirmedTxs : `object`

Structure of GraphQLClient.ResponseGetUnconfirmedTxs

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name              | Type                                              |
| ----------------- | ------------------------------------------------- |
| code              | `string`                                          |
| ...page           | [`PageInfo`](#GraphQLClient.PageInfo)             |
| ...unconfirmedTxs | [`UnconfirmedTxs`](#GraphQLClient.UnconfirmedTxs) |

### GraphQLClient.ResponseGetValidatorsInfo : `object`

Structure of GraphQLClient.ResponseGetValidatorsInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name              | Type                                              |
| ----------------- | ------------------------------------------------- |
| code              | `string`                                          |
| ...validatorsInfo | [`ValidatorsInfo`](#GraphQLClient.ValidatorsInfo) |

### GraphQLClient.ResponseListAssetTransactions : `object`

Structure of GraphQLClient.ResponseListAssetTransactions

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| code         | `string`                                      |
| ...page      | [`PageInfo`](#GraphQLClient.PageInfo)         |
| transactions | `Array.<...GraphQLClient.IndexedTransaction>` |

### GraphQLClient.ResponseListAssets : `object`

Structure of GraphQLClient.ResponseListAssets

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                         |
| ------- | -------------------------------------------- |
| code    | `string`                                     |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)        |
| assets  | `Array.<...GraphQLClient.IndexedAssetState>` |

### GraphQLClient.ResponseListBlocks : `object`

Structure of GraphQLClient.ResponseListBlocks

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                    |
| ------- | --------------------------------------- |
| code    | `string`                                |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)   |
| blocks  | `Array.<...GraphQLClient.IndexedBlock>` |

### GraphQLClient.ResponseListDelegations : `object`

Structure of GraphQLClient.ResponseListDelegations

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                              |
| ----------- | ------------------------------------------------- |
| code        | `string`                                          |
| ...page     | [`PageInfo`](#GraphQLClient.PageInfo)             |
| delegations | `Array.<...GraphQLClient.IndexedDelegationState>` |

### GraphQLClient.ResponseListFactories : `object`

Structure of GraphQLClient.ResponseListFactories

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                           |
| --------- | ---------------------------------------------- |
| code      | `string`                                       |
| ...page   | [`PageInfo`](#GraphQLClient.PageInfo)          |
| factories | `Array.<...GraphQLClient.IndexedFactoryState>` |

### GraphQLClient.ResponseListRollupBlocks : `object`

Structure of GraphQLClient.ResponseListRollupBlocks

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                          |
| ------- | --------------------------------------------- |
| code    | `string`                                      |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)         |
| blocks  | `Array.<...GraphQLClient.IndexedRollupBlock>` |

### GraphQLClient.ResponseListRollupValidators : `object`

Structure of GraphQLClient.ResponseListRollupValidators

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                              |
| ---------- | ------------------------------------------------- |
| code       | `string`                                          |
| ...page    | [`PageInfo`](#GraphQLClient.PageInfo)             |
| validators | `Array.<...GraphQLClient.IndexedRollupValidator>` |

### GraphQLClient.ResponseListRollups : `object`

Structure of GraphQLClient.ResponseListRollups

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                          |
| ------- | --------------------------------------------- |
| code    | `string`                                      |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)         |
| rollups | `Array.<...GraphQLClient.IndexedRollupState>` |

### GraphQLClient.ResponseListStakes : `object`

Structure of GraphQLClient.ResponseListStakes

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                         |
| ------- | -------------------------------------------- |
| code    | `string`                                     |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)        |
| stakes  | `Array.<...GraphQLClient.IndexedStakeState>` |

### GraphQLClient.ResponseListTokenFactories : `object`

Structure of GraphQLClient.ResponseListTokenFactories

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                |
| -------------- | --------------------------------------------------- |
| code           | `string`                                            |
| ...page        | [`PageInfo`](#GraphQLClient.PageInfo)               |
| tokenFactories | `Array.<...GraphQLClient.IndexedTokenFactoryState>` |

### GraphQLClient.ResponseListTokenFlows : `object`

Structure of GraphQLClient.ResponseListTokenFlows

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                        |
| ------- | ------------------------------------------- |
| code    | `string`                                    |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)       |
| data    | `Array.<...GraphQLClient.IndexedTokenFlow>` |

### GraphQLClient.ResponseListTokens : `object`

Structure of GraphQLClient.ResponseListTokens

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                         |
| ------- | -------------------------------------------- |
| code    | `string`                                     |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)        |
| tokens  | `Array.<...GraphQLClient.IndexedTokenState>` |

### GraphQLClient.ResponseListTopAccounts : `object`

Structure of GraphQLClient.ResponseListTopAccounts

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                           |
| -------- | ---------------------------------------------- |
| code     | `string`                                       |
| ...page  | [`PageInfo`](#GraphQLClient.PageInfo)          |
| accounts | `Array.<...GraphQLClient.IndexedAccountState>` |

### GraphQLClient.ResponseListTransactions : `object`

Structure of GraphQLClient.ResponseListTransactions

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| code         | `string`                                      |
| ...page      | [`PageInfo`](#GraphQLClient.PageInfo)         |
| transactions | `Array.<...GraphQLClient.IndexedTransaction>` |

### GraphQLClient.ResponseSearch : `object`

Structure of GraphQLClient.ResponseSearch

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                    |
| ------- | --------------------------------------- |
| code    | `string`                                |
| ...page | [`PageInfo`](#GraphQLClient.PageInfo)   |
| results | `Array.<...GraphQLClient.SearchResult>` |

### GraphQLClient.ResponseSendTx : `object`

Structure of GraphQLClient.ResponseSendTx

Checkout the following snippet for the format of ResponseSendTx:

```json
{
  "code": "abc",
  "hash": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| code | `string` |
| hash | `string` |

### GraphQLClient.ResponseVerifyAccountRisk : `object`

Structure of GraphQLClient.ResponseVerifyAccountRisk

Checkout the following snippet for the format of ResponseVerifyAccountRisk:

```json
{
  "code": "abc",
  "data": {
    "isRisky": true,
    "reason": "abc",
    "data": {
      "address": "abc",
      "balance": "abc",
      "transferIn": "abc",
      "transferOut": "abc"
    }
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                                                |
| ------- | ------------------------------------------------------------------- |
| code    | `string`                                                            |
| ...data | [`VerifyAccountRiskResult`](#GraphQLClient.VerifyAccountRiskResult) |

### GraphQLClient.ResumeRollupTx : `object`

Structure of GraphQLClient.ResumeRollupTx

Checkout the following snippet for the format of ResumeRollupTx:

```json
{
  "rollup": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| rollup  | `string`                    |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.ReturnStakeTx : `object`

Structure of GraphQLClient.ReturnStakeTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                        |
| ------- | ------------------------------------------- |
| address | `string`                                    |
| outputs | `Array.<...GraphQLClient.TransactionInput>` |
| message | `string`                                    |
| ...data | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.RevokeDelegateTx : `object`

Structure of GraphQLClient.RevokeDelegateTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                        |
| -------- | --------------------------- |
| address  | `string`                    |
| to       | `string`                    |
| typeUrls | `Array.<string>`            |
| ...data  | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.RevokeStakeTx : `object`

Structure of GraphQLClient.RevokeStakeTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                        |
| ------- | ------------------------------------------- |
| address | `string`                                    |
| outputs | `Array.<...GraphQLClient.TransactionInput>` |
| ...data | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.RollupBlock : `object`

Structure of GraphQLClient.RollupBlock

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| hash         | `string`                                      |
| height       | `string`                                      |
| merkleRoot   | `string`                                      |
| previousHash | `string`                                      |
| txsHash      | `string`                                      |
| txs          | `Array.<string>`                              |
| proposer     | `string`                                      |
| signatures   | `Array.<...GraphQLClient.Multisig>`           |
| rollup       | `string`                                      |
| mintedAmount | `string`                                      |
| burnedAmount | `string`                                      |
| rewardAmount | `string`                                      |
| minReward    | `string`                                      |
| governance   | `boolean`                                     |
| ...context   | [`StateContext`](#GraphQLClient.StateContext) |
| ...data      | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.RollupState : `object`

Structure of GraphQLClient.RollupState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                 | Type                                                    |
| -------------------- | ------------------------------------------------------- |
| address              | `string`                                                |
| tokenAddress         | `string`                                                |
| vaultAddress         | `string`                                                |
| contractAddress      | `string`                                                |
| seedValidators       | `Array.<...GraphQLClient.RollupValidator>`              |
| validators           | `Array.<...GraphQLClient.RollupValidator>`              |
| minStakeAmount       | `string`                                                |
| maxStakeAmount       | `string`                                                |
| minSignerCount       | `number`                                                |
| maxSignerCount       | `number`                                                |
| minBlockSize         | `number`                                                |
| maxBlockSize         | `number`                                                |
| minBlockInterval     | `number`                                                |
| minBlockConfirmation | `number`                                                |
| issuer               | `string`                                                |
| depositFeeRate       | `number`                                                |
| withdrawFeeRate      | `number`                                                |
| proposerFeeShare     | `number`                                                |
| publisherFeeShare    | `number`                                                |
| minDepositAmount     | `string`                                                |
| minWithdrawAmount    | `string`                                                |
| blockHeight          | `string`                                                |
| blockHash            | `string`                                                |
| ...tokenInfo         | [`IndexedTokenInput`](#GraphQLClient.IndexedTokenInput) |
| totalDepositAmount   | `string`                                                |
| totalWithdrawAmount  | `string`                                                |
| maxDepositAmount     | `string`                                                |
| maxWithdrawAmount    | `string`                                                |
| minDepositFee        | `string`                                                |
| maxDepositFee        | `string`                                                |
| minWithdrawFee       | `string`                                                |
| maxWithdrawFee       | `string`                                                |
| paused               | `boolean`                                               |
| ...foreignToken      | [`ForeignToken`](#GraphQLClient.ForeignToken)           |
| leaveWaitingPeriod   | `number`                                                |
| publishWaitingPeriod | `number`                                                |
| publishSlashRate     | `number`                                                |
| migrateHistory       | `Array.<string>`                                        |
| closed               | `boolean`                                               |
| vaultHistory         | `Array.<string>`                                        |
| ...context           | [`StateContext`](#GraphQLClient.StateContext)           |
| ...data              | [`Any`](#GraphQLClient.Any)                             |

### GraphQLClient.RollupValidator : `object`

Structure of GraphQLClient.RollupValidator

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type     |
| -------- | -------- |
| pk       | `string` |
| address  | `string` |
| endpoint | `string` |

### GraphQLClient.SearchResult : `object`

Structure of GraphQLClient.SearchResult

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type             |
| ----------- | ---------------- |
| type        | `string`         |
| id          | `string`         |
| title       | `string`         |
| subtitle    | `string`         |
| description | `string`         |
| tags        | `Array.<string>` |
| timestamp   | `string`         |

### GraphQLClient.SlashStakeTx : `object`

Structure of GraphQLClient.SlashStakeTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                        |
| ------- | ------------------------------------------- |
| address | `string`                                    |
| outputs | `Array.<...GraphQLClient.TransactionInput>` |
| message | `string`                                    |
| ...data | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.StakeState : `object`

Structure of GraphQLClient.StakeState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                          |
| ------------------- | --------------------------------------------- |
| address             | `string`                                      |
| sender              | `string`                                      |
| receiver            | `string`                                      |
| tokens              | `Array.<...GraphQLClient.IndexedTokenInput>`  |
| assets              | `Array.<string>`                              |
| revocable           | `boolean`                                     |
| message             | `string`                                      |
| revokeWaitingPeriod | `number`                                      |
| revokedTokens       | `Array.<...GraphQLClient.IndexedTokenInput>`  |
| revokedAssets       | `Array.<string>`                              |
| slashers            | `Array.<string>`                              |
| nonce               | `string`                                      |
| ...context          | [`StateContext`](#GraphQLClient.StateContext) |
| ...data             | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.StakeTx : `object`

Structure of GraphQLClient.StakeTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                        |
| ------------------- | ------------------------------------------- |
| address             | `string`                                    |
| receiver            | `string`                                    |
| inputs              | `Array.<...GraphQLClient.TransactionInput>` |
| locked              | `boolean`                                   |
| message             | `string`                                    |
| revokeWaitingPeriod | `number`                                    |
| slashers            | `Array.<string>`                            |
| nonce               | `string`                                    |
| ...data             | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.StateContext : `object`

Structure of GraphQLClient.StateContext

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                                |
| ---------------- | --------------------------------------------------- |
| ...genesisTx     | [`TransactionInfo`](#GraphQLClient.TransactionInfo) |
| ...renaissanceTx | [`TransactionInfo`](#GraphQLClient.TransactionInfo) |
| genesisTime      | `string`                                            |
| renaissanceTime  | `string`                                            |

### GraphQLClient.TokenDistribution : `object`

Structure of GraphQLClient.TokenDistribution

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type     |
| ------------ | -------- |
| tokenAddress | `string` |
| txTime       | `string` |
| account      | `string` |
| gas          | `string` |
| fee          | `string` |
| slashedVault | `string` |
| stake        | `string` |
| revokedStake | `string` |
| gasStake     | `string` |

### GraphQLClient.TokenFactoryState : `object`

Structure of GraphQLClient.TokenFactoryState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                          |
| --------------- | --------------------------------------------- |
| address         | `string`                                      |
| owner           | `string`                                      |
| tokenAddress    | `string`                                      |
| reserveAddress  | `string`                                      |
| ...curve        | [`CurveConfig`](#GraphQLClient.CurveConfig)   |
| currentSupply   | `string`                                      |
| reserveBalance  | `string`                                      |
| feeRate         | `number`                                      |
| status          | `string`                                      |
| ...token        | [`TokenState`](#GraphQLClient.TokenState)     |
| ...reserveToken | [`TokenState`](#GraphQLClient.TokenState)     |
| ...context      | [`StateContext`](#GraphQLClient.StateContext) |
| ...data         | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.TokenInfo : `object`

Structure of GraphQLClient.TokenInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                        |
| -------------- | --------------------------- |
| address        | `string`                    |
| symbol         | `string`                    |
| decimal        | `number`                    |
| unit           | `string`                    |
| name           | `string`                    |
| description    | `string`                    |
| icon           | `string`                    |
| maxTotalSupply | `string`                    |
| ...metadata    | [`Any`](#GraphQLClient.Any) |
| website        | `string`                    |
| spenders       | `Array.<string>`            |
| minters        | `Array.<string>`            |
| type           | `string`                    |

### GraphQLClient.TokenInput : `object`

Structure of GraphQLClient.TokenInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| value   | `string` |

### GraphQLClient.TokenLimit : `object`

Structure of GraphQLClient.TokenLimit

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                    |
| -------------- | --------------------------------------- |
| address        | `string`                                |
| to             | `Array.<string>`                        |
| txCount        | `number`                                |
| txAllowance    | `string`                                |
| totalAllowance | `string`                                |
| validUntil     | `string`                                |
| ...rate        | [`RateLimit`](#GraphQLClient.RateLimit) |
| txSent         | `number`                                |
| spentAllowance | `string`                                |
| lastTx         | `string`                                |
| decimal        | `number`                                |
| symbol         | `string`                                |

### GraphQLClient.TokenMeta : `object`

Structure of GraphQLClient.TokenMeta

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| balance | `string` |
| decimal | `number` |
| unit    | `string` |
| symbol  | `string` |

### GraphQLClient.TokenState : `object`

Structure of GraphQLClient.TokenState

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                          |
| ------------------- | --------------------------------------------- |
| address             | `string`                                      |
| issuer              | `string`                                      |
| name                | `string`                                      |
| description         | `string`                                      |
| symbol              | `string`                                      |
| unit                | `string`                                      |
| decimal             | `number`                                      |
| icon                | `string`                                      |
| totalSupply         | `string`                                      |
| ...foreignToken     | [`ForeignToken`](#GraphQLClient.ForeignToken) |
| tokenFactoryAddress | `string`                                      |
| initialSupply       | `string`                                      |
| maxTotalSupply      | `string`                                      |
| ...metadata         | [`Any`](#GraphQLClient.Any)                   |
| ...context          | [`StateContext`](#GraphQLClient.StateContext) |
| website             | `string`                                      |
| spenders            | `Array.<string>`                              |
| minters             | `Array.<string>`                              |
| type                | `string`                                      |
| ...data             | [`Any`](#GraphQLClient.Any)                   |

### GraphQLClient.TokenSymbol : `object`

Structure of GraphQLClient.TokenSymbol

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| symbol  | `string` |
| decimal | `number` |
| unit    | `string` |

### GraphQLClient.Transaction : `object`

Structure of GraphQLClient.Transaction

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                                |
| ---------- | ----------------------------------- |
| from       | `string`                            |
| delegator  | `string`                            |
| nonce      | `string`                            |
| chainId    | `string`                            |
| pk         | `string`                            |
| signature  | `string`                            |
| signatures | `Array.<...GraphQLClient.Multisig>` |
| itxJson    | `object`                            |
| sender     | `string`                            |
| receiver   | `string`                            |
| serviceFee | `string`                            |
| gasFee     | `string`                            |
| gasPaid    | `string`                            |

### GraphQLClient.TransactionConfig : `object`

Structure of GraphQLClient.TransactionConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                              |
| ------------ | ------------------------------------------------- |
| maxAssetSize | `number`                                          |
| maxListSize  | `number`                                          |
| maxMultisig  | `number`                                          |
| ...delegate  | [`DelegateConfig`](#GraphQLClient.DelegateConfig) |
| txFee        | `Array.<...GraphQLClient.TxFeeConfig>`            |
| ...txGas     | [`TxGasConfig`](#GraphQLClient.TxGasConfig)       |
| ...txStake   | [`TxStakeConfig`](#GraphQLClient.TxStakeConfig)   |

### GraphQLClient.TransactionInfo : `object`

Structure of GraphQLClient.TransactionInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type                                          |
| ------------ | --------------------------------------------- |
| ...tx        | [`Transaction`](#GraphQLClient.Transaction)   |
| height       | `string`                                      |
| index        | `number`                                      |
| hash         | `string`                                      |
| tags         | `Array.<...GraphQLClient.KVPair>`             |
| code         | `string`                                      |
| time         | `string`                                      |
| receipts     | `Array.<...GraphQLClient.TransactionReceipt>` |
| sender       | `string`                                      |
| receiver     | `string`                                      |
| tokenSymbols | `Array.<...GraphQLClient.TokenSymbol>`        |

### GraphQLClient.TransactionInput : `object`

Structure of GraphQLClient.TransactionInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type                                  |
| ------ | ------------------------------------- |
| owner  | `string`                              |
| tokens | `Array.<...GraphQLClient.TokenInput>` |
| assets | `Array.<string>`                      |

### GraphQLClient.TransactionReceipt : `object`

Structure of GraphQLClient.TransactionReceipt

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                     |
| ------- | ---------------------------------------- |
| address | `string`                                 |
| changes | `Array.<...GraphQLClient.ReceiptChange>` |

### GraphQLClient.TransferTx : `object`

Structure of GraphQLClient.TransferTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                        |
| ------- | --------------------------- |
| to      | `string`                    |
| value   | `string`                    |
| assets  | `Array.<string>`            |
| ...data | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.TransferV2Tx : `object`

Structure of GraphQLClient.TransferV2Tx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                  |
| ------- | ------------------------------------- |
| to      | `string`                              |
| value   | `string`                              |
| assets  | `Array.<string>`                      |
| tokens  | `Array.<...GraphQLClient.TokenInput>` |
| ...data | [`Any`](#GraphQLClient.Any)           |

### GraphQLClient.TransferV3Tx : `object`

Structure of GraphQLClient.TransferV3Tx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                        |
| ------- | ------------------------------------------- |
| inputs  | `Array.<...GraphQLClient.TransactionInput>` |
| outputs | `Array.<...GraphQLClient.TransactionInput>` |
| ...data | [`Any`](#GraphQLClient.Any)                 |

### GraphQLClient.TxFeeConfig : `object`

Structure of GraphQLClient.TxFeeConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| typeUrl | `string` |
| fee     | `string` |

### GraphQLClient.TxGasConfig : `object`

Structure of GraphQLClient.TxGasConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type     |
| --------------- | -------- |
| price           | `string` |
| createState     | `string` |
| updateState     | `string` |
| dataStorage     | `string` |
| minStake        | `string` |
| maxStake        | `string` |
| stakeLockPeriod | `string` |

### GraphQLClient.TxStakeConfig : `object`

Structure of GraphQLClient.TxStakeConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type     |
| --------------------- | -------- |
| createToken           | `string` |
| createTokenLockPeriod | `string` |

### GraphQLClient.UnconfirmedTxs : `object`

Structure of GraphQLClient.UnconfirmedTxs

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type                                   |
| ---- | -------------------------------------- |
| nTxs | `number`                               |
| txs  | `Array.<...GraphQLClient.Transaction>` |

### GraphQLClient.UpdateAssetTx : `object`

Structure of GraphQLClient.UpdateAssetTx

Checkout the following snippet for the format of UpdateAssetTx:

```json
{
  "address": "abc",
  "moniker": "abc",
  "consumed": true,
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                        |
| -------- | --------------------------- |
| address  | `string`                    |
| moniker  | `string`                    |
| consumed | `boolean`                   |
| ...data  | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.UpdateRollupTx : `object`

Structure of GraphQLClient.UpdateRollupTx

Checkout the following snippet for the format of UpdateRollupTx:

```json
{
  "minStakeAmount": "abc",
  "maxStakeAmount": "abc",
  "minDepositAmount": "abc",
  "minWithdrawAmount": "abc",
  "maxDepositAmount": "abc",
  "maxWithdrawAmount": "abc",
  "minDepositFee": "abc",
  "maxDepositFee": "abc",
  "minWithdrawFee": "abc",
  "maxWithdrawFee": "abc",
  "rollup": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                 | Type                        |
| -------------------- | --------------------------- |
| minStakeAmount       | `string`                    |
| maxStakeAmount       | `string`                    |
| minSignerCount       | `number`                    |
| maxSignerCount       | `number`                    |
| minBlockSize         | `number`                    |
| maxBlockSize         | `number`                    |
| minBlockInterval     | `number`                    |
| minBlockConfirmation | `number`                    |
| depositFeeRate       | `number`                    |
| withdrawFeeRate      | `number`                    |
| proposerFeeShare     | `number`                    |
| minDepositAmount     | `string`                    |
| minWithdrawAmount    | `string`                    |
| maxDepositAmount     | `string`                    |
| maxWithdrawAmount    | `string`                    |
| minDepositFee        | `string`                    |
| maxDepositFee        | `string`                    |
| minWithdrawFee       | `string`                    |
| maxWithdrawFee       | `string`                    |
| publisherFeeShare    | `number`                    |
| leaveWaitingPeriod   | `number`                    |
| publishWaitingPeriod | `number`                    |
| publishSlashRate     | `number`                    |
| rollup               | `string`                    |
| ...data              | [`Any`](#GraphQLClient.Any) |

### GraphQLClient.UpdateTokenFactoryTx : `object`

Structure of GraphQLClient.UpdateTokenFactoryTx

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                    |
| -------- | --------------------------------------- |
| address  | `string`                                |
| feeRate  | `number`                                |
| ...token | [`TokenInfo`](#GraphQLClient.TokenInfo) |
| ...data  | [`Any`](#GraphQLClient.Any)             |

### GraphQLClient.UpgradeInfo : `object`

Structure of GraphQLClient.UpgradeInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| height  | `string` |
| version | `string` |

### GraphQLClient.UpgradeNodeTx : `object`

Structure of GraphQLClient.UpgradeNodeTx

Checkout the following snippet for the format of UpgradeNodeTx:

```json
{
  "version": "abc",
  "override": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type      |
| -------- | --------- |
| height   | `string`  |
| version  | `string`  |
| override | `boolean` |

### GraphQLClient.UpgradeTask : `object`

Structure of GraphQLClient.UpgradeTask

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name     | Type                                     |
| -------- | ---------------------------------------- |
| ...type  | `GraphQLClient.UpgradeType`              |
| dataHash | `string`                                 |
| actions  | `Array.<...GraphQLClient.UpgradeAction>` |

### GraphQLClient.UpgradeTasks : `object`

Structure of GraphQLClient.UpgradeTasks

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type                                   |
| ---- | -------------------------------------- |
| item | `Array.<...GraphQLClient.UpgradeTask>` |

### GraphQLClient.Validator : `object`

Structure of GraphQLClient.Validator

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| power   | `string` |

### GraphQLClient.ValidatorInfo : `object`

Structure of GraphQLClient.ValidatorInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                |
| ---------------- | ----------------------------------- |
| address          | `string`                            |
| ...pubKey        | [`PubKey`](#GraphQLClient.PubKey)   |
| votingPower      | `string`                            |
| proposerPriority | `string`                            |
| name             | `string`                            |
| ...geoInfo       | [`GeoInfo`](#GraphQLClient.GeoInfo) |

### GraphQLClient.ValidatorsInfo : `object`

Structure of GraphQLClient.ValidatorsInfo

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type                                     |
| ----------- | ---------------------------------------- |
| blockHeight | `string`                                 |
| validators  | `Array.<...GraphQLClient.ValidatorInfo>` |

### GraphQLClient.VariableInput : `object`

Structure of GraphQLClient.VariableInput

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name        | Type      |
| ----------- | --------- |
| name        | `string`  |
| value       | `string`  |
| description | `string`  |
| required    | `boolean` |

### GraphQLClient.VaultConfig : `object`

Structure of GraphQLClient.VaultConfig

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type             |
| ------------ | ---------------- |
| slashedStake | `string`         |
| txFee        | `string`         |
| txGas        | `Array.<string>` |

### GraphQLClient.VerifyAccountRiskResult : `object`

Structure of GraphQLClient.VerifyAccountRiskResult

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type                                                                                           |
| ------- | ---------------------------------------------------------------------------------------------- |
| isRisky | `boolean`                                                                                      |
| reason  | `string`                                                                                       |
| ...data | [`VerifyAccountRiskResult\_BalanceRisky`](#GraphQLClient.VerifyAccountRiskResult_BalanceRisky) |

### GraphQLClient.VerifyAccountRiskResult\_BalanceRisky : `object`

Structure of GraphQLClient.VerifyAccountRiskResult\_BalanceRisky

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type     |
| ------------ | -------- |
| address      | `string` |
| balance      | `string` |
| transferIn   | `string` |
| transferOut  | `string` |
| accountCount | `number` |
| txCount      | `number` |

### GraphQLClient.Version : `object`

Structure of GraphQLClient.Version

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name  | Type     |
| ----- | -------- |
| block | `string` |
| app   | `string` |

### GraphQLClient.WalletType : `object`

Structure of GraphQLClient.WalletType

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name       | Type                         |
| ---------- | ---------------------------- |
| ...pk      | `GraphQLClient.KeyType`      |
| ...hash    | `GraphQLClient.HashType`     |
| ...address | `GraphQLClient.EncodingType` |
| ...role    | `GraphQLClient.RoleType`     |

### GraphQLClient.WithdrawTokenV2Tx : `object`

Structure of GraphQLClient.WithdrawTokenV2Tx

Checkout the following snippet for the format of WithdrawTokenV2Tx:

```json
{
  "token": {
    "address": "abc",
    "value": "abc"
  },
  "to": "abc",
  "rollup": "abc",
  "proposer": "abc",
  "maxFee": "abc",
  "actualFee": "abc",
  "data": {
    "typeUrl": "abc",
    "value": "abc"
  }
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                      |
| --------- | ----------------------------------------- |
| ...token  | [`TokenInput`](#GraphQLClient.TokenInput) |
| to        | `string`                                  |
| rollup    | `string`                                  |
| proposer  | `string`                                  |
| maxFee    | `string`                                  |
| actualFee | `string`                                  |
| ...data   | [`Any`](#GraphQLClient.Any)               |

### GraphQLClient.GetAccountStateParams : `object`

Structure of GraphQLClient.GetAccountStateParams

Checkout the following snippet for the format of GetAccountStateParams:

```json
{
  "address": "abc",
  "height": "abc",
  "keys": [
    "abc"
  ],
  "traceMigration": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type             |
| -------------- | ---------------- |
| address        | `string`         |
| height         | `string`         |
| keys           | `Array.<string>` |
| traceMigration | `boolean`        |

### GraphQLClient.GetAssetStateParams : `object`

Structure of GraphQLClient.GetAssetStateParams

Checkout the following snippet for the format of GetAssetStateParams:

```json
{
  "address": "abc",
  "height": "abc",
  "keys": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| address | `string`         |
| height  | `string`         |
| keys    | `Array.<string>` |

### GraphQLClient.GetFactoryStateParams : `object`

Structure of GraphQLClient.GetFactoryStateParams

Checkout the following snippet for the format of GetFactoryStateParams:

```json
{
  "address": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |

### GraphQLClient.GetDelegateStateParams : `object`

Structure of GraphQLClient.GetDelegateStateParams

Checkout the following snippet for the format of GetDelegateStateParams:

```json
{
  "address": "abc",
  "height": "abc",
  "keys": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| address | `string`         |
| height  | `string`         |
| keys    | `Array.<string>` |

### GraphQLClient.GetTokenStateParams : `object`

Structure of GraphQLClient.GetTokenStateParams

Checkout the following snippet for the format of GetTokenStateParams:

```json
{
  "address": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |

### GraphQLClient.GetEvidenceStateParams : `object`

Structure of GraphQLClient.GetEvidenceStateParams

Checkout the following snippet for the format of GetEvidenceStateParams:

```json
{
  "hash": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| hash | `string` |

### GraphQLClient.GetForgeStateParams : `object`

Structure of GraphQLClient.GetForgeStateParams

Checkout the following snippet for the format of GetForgeStateParams:

```json
{
  "height": "abc",
  "keys": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type             |
| ------ | ---------------- |
| height | `string`         |
| keys   | `Array.<string>` |

### GraphQLClient.GetTokenFactoryStateParams : `object`

Structure of GraphQLClient.GetTokenFactoryStateParams

Checkout the following snippet for the format of GetTokenFactoryStateParams:

```json
{
  "address": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |

### GraphQLClient.GetTxParams : `object`

Structure of GraphQLClient.GetTxParams

Checkout the following snippet for the format of GetTxParams:

```json
{
  "hash": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name | Type     |
| ---- | -------- |
| hash | `string` |

### GraphQLClient.GetBlockParams : `object`

Structure of GraphQLClient.GetBlockParams

Checkout the following snippet for the format of GetBlockParams:

```json
{
  "height": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type     |
| ------ | -------- |
| height | `string` |

### GraphQLClient.GetBlocksParams : `object`

Structure of GraphQLClient.GetBlocksParams

Checkout the following snippet for the format of GetBlocksParams:

```json
{
  "emptyExcluded": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name            | Type                                                  |
| --------------- | ----------------------------------------------------- |
| emptyExcluded   | `boolean`                                             |
| ...heightFilter | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...paging       | [`PageInput`](#GraphQLClient.PageInput)               |

### GraphQLClient.GetUnconfirmedTxsParams : `object`

Structure of GraphQLClient.GetUnconfirmedTxsParams

Checkout the following snippet for the format of GetUnconfirmedTxsParams:

```json
{}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                    |
| --------- | --------------------------------------- |
| ...paging | [`PageInput`](#GraphQLClient.PageInput) |

### GraphQLClient.GetConfigParams : `object`

Structure of GraphQLClient.GetConfigParams

Checkout the following snippet for the format of GetConfigParams:

```json
{
  "parsed": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type      |
| ------ | --------- |
| parsed | `boolean` |

### GraphQLClient.ListAssetTransactionsParams : `object`

Structure of GraphQLClient.ListAssetTransactionsParams

Checkout the following snippet for the format of ListAssetTransactionsParams:

```json
{
  "address": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                    |
| --------- | --------------------------------------- |
| address   | `string`                                |
| ...paging | [`PageInput`](#GraphQLClient.PageInput) |

### GraphQLClient.ListAssetsParams : `object`

Structure of GraphQLClient.ListAssetsParams

Checkout the following snippet for the format of ListAssetsParams:

```json
{
  "ownerAddress": "abc",
  "factoryAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                |
| -------------- | --------------------------------------------------- |
| ownerAddress   | `string`                                            |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput)             |
| factoryAddress | `string`                                            |
| ...timeFilter  | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.ListBlocksParams : `object`

Structure of GraphQLClient.ListBlocksParams

Checkout the following snippet for the format of ListBlocksParams:

```json
{
  "proposer": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                   | Type                                                  |
| ---------------------- | ----------------------------------------------------- |
| ...heightFilter        | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...numInvalidTxsFilter | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...numTxsFilter        | [`RangeFilterInput`](#GraphQLClient.RangeFilterInput) |
| ...paging              | [`PageInput`](#GraphQLClient.PageInput)               |
| proposer               | `string`                                              |
| ...timeFilter          | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)   |

### GraphQLClient.ListTopAccountsParams : `object`

Structure of GraphQLClient.ListTopAccountsParams

Checkout the following snippet for the format of ListTopAccountsParams:

```json
{
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| tokenAddress  | `string`                                            |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.ListTransactionsParams : `object`

Structure of GraphQLClient.ListTransactionsParams

Checkout the following snippet for the format of ListTransactionsParams:

```json
{
  "includeItxData": true
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                                |
| --------------------- | ------------------------------------------------------------------- |
| ...addressFilter      | [`AddressFilterInput`](#GraphQLClient.AddressFilterInput)           |
| ...paging             | [`PageInput`](#GraphQLClient.PageInput)                             |
| ...timeFilter         | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)                 |
| ...typeFilter         | [`TypeFilterInput`](#GraphQLClient.TypeFilterInput)                 |
| ...validityFilter     | [`ValidityFilterInput`](#GraphQLClient.ValidityFilterInput)         |
| ...factoryFilter      | [`FactoryFilterInput`](#GraphQLClient.FactoryFilterInput)           |
| ...tokenFilter        | [`TokenFilterInput`](#GraphQLClient.TokenFilterInput)               |
| ...assetFilter        | [`AssetFilterInput`](#GraphQLClient.AssetFilterInput)               |
| ...accountFilter      | [`AccountFilterInput`](#GraphQLClient.AccountFilterInput)           |
| ...txFilter           | [`TxFilterInput`](#GraphQLClient.TxFilterInput)                     |
| ...rollupFilter       | [`RollupFilterInput`](#GraphQLClient.RollupFilterInput)             |
| ...stakeFilter        | [`StakeFilterInput`](#GraphQLClient.StakeFilterInput)               |
| ...delegationFilter   | [`DelegationFilterInput`](#GraphQLClient.DelegationFilterInput)     |
| ...tokenFactoryFilter | [`TokenFactoryFilterInput`](#GraphQLClient.TokenFactoryFilterInput) |
| includeItxData        | `boolean`                                                           |

### GraphQLClient.ListTokensParams : `object`

Structure of GraphQLClient.ListTokensParams

Checkout the following snippet for the format of ListTokensParams:

```json
{
  "issuerAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| issuerAddress | `string`                                            |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.ListFactoriesParams : `object`

Structure of GraphQLClient.ListFactoriesParams

Checkout the following snippet for the format of ListFactoriesParams:

```json
{
  "ownerAddress": "abc",
  "addressList": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| ownerAddress  | `string`                                            |
| addressList   | `Array.<string>`                                    |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.GetAccountTokensParams : `object`

Structure of GraphQLClient.GetAccountTokensParams

Checkout the following snippet for the format of GetAccountTokensParams:

```json
{
  "address": "abc",
  "token": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| address | `string` |
| token   | `string` |

### GraphQLClient.GetStakeStateParams : `object`

Structure of GraphQLClient.GetStakeStateParams

Checkout the following snippet for the format of GetStakeStateParams:

```json
{
  "address": "abc",
  "height": "abc",
  "keys": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| address | `string`         |
| height  | `string`         |
| keys    | `Array.<string>` |

### GraphQLClient.ListStakesParams : `object`

Structure of GraphQLClient.ListStakesParams

Checkout the following snippet for the format of ListStakesParams:

```json
{}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name             | Type                                                      |
| ---------------- | --------------------------------------------------------- |
| ...addressFilter | [`AddressFilterInput`](#GraphQLClient.AddressFilterInput) |
| ...assetFilter   | [`AssetFilterInput`](#GraphQLClient.AssetFilterInput)     |
| ...timeFilter    | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)       |
| ...paging        | [`PageInput`](#GraphQLClient.PageInput)                   |

### GraphQLClient.GetRollupStateParams : `object`

Structure of GraphQLClient.GetRollupStateParams

Checkout the following snippet for the format of GetRollupStateParams:

```json
{
  "address": "abc",
  "height": "abc",
  "keys": [
    "abc"
  ]
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type             |
| ------- | ---------------- |
| address | `string`         |
| height  | `string`         |
| keys    | `Array.<string>` |

### GraphQLClient.ListRollupsParams : `object`

Structure of GraphQLClient.ListRollupsParams

Checkout the following snippet for the format of ListRollupsParams:

```json
{
  "tokenAddress": "abc",
  "erc20TokenAddress": "abc",
  "foreignTokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                | Type                                                |
| ------------------- | --------------------------------------------------- |
| ...paging           | [`PageInput`](#GraphQLClient.PageInput)             |
| tokenAddress        | `string`                                            |
| erc20TokenAddress   | `string`                                            |
| foreignTokenAddress | `string`                                            |
| ...timeFilter       | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.GetRollupBlockParams : `object`

Structure of GraphQLClient.GetRollupBlockParams

Checkout the following snippet for the format of GetRollupBlockParams:

```json
{
  "hash": "abc",
  "height": "abc",
  "rollupAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type     |
| ------------- | -------- |
| hash          | `string` |
| height        | `string` |
| rollupAddress | `string` |

### GraphQLClient.ListRollupBlocksParams : `object`

Structure of GraphQLClient.ListRollupBlocksParams

Checkout the following snippet for the format of ListRollupBlocksParams:

```json
{
  "rollupAddress": "abc",
  "tokenAddress": "abc",
  "proposer": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name               | Type                                                          |
| ------------------ | ------------------------------------------------------------- |
| ...paging          | [`PageInput`](#GraphQLClient.PageInput)                       |
| rollupAddress      | `string`                                                      |
| tokenAddress       | `string`                                                      |
| proposer           | `string`                                                      |
| ...validatorFilter | [`ValidatorFilterInput`](#GraphQLClient.ValidatorFilterInput) |
| ...txFilter        | [`TxFilterInput`](#GraphQLClient.TxFilterInput)               |
| ...timeFilter      | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput)           |

### GraphQLClient.ListRollupValidatorsParams : `object`

Structure of GraphQLClient.ListRollupValidatorsParams

Checkout the following snippet for the format of ListRollupValidatorsParams:

```json
{
  "rollupAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                    |
| ------------- | --------------------------------------- |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput) |
| rollupAddress | `string`                                |

### GraphQLClient.ListDelegationsParams : `object`

Structure of GraphQLClient.ListDelegationsParams

Checkout the following snippet for the format of ListDelegationsParams:

```json
{
  "from": "abc",
  "to": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name          | Type                                                |
| ------------- | --------------------------------------------------- |
| from          | `string`                                            |
| to            | `string`                                            |
| ...paging     | [`PageInput`](#GraphQLClient.PageInput)             |
| ...timeFilter | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.SearchParams : `object`

Structure of GraphQLClient.SearchParams

Checkout the following snippet for the format of SearchParams:

```json
{
  "keyword": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name      | Type                                    |
| --------- | --------------------------------------- |
| ...paging | [`PageInput`](#GraphQLClient.PageInput) |
| keyword   | `string`                                |

### GraphQLClient.EstimateGasParams : `object`

Structure of GraphQLClient.EstimateGasParams

Checkout the following snippet for the format of EstimateGasParams:

```json
{
  "typeUrl": "abc",
  "tx": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name    | Type     |
| ------- | -------- |
| typeUrl | `string` |
| tx      | `string` |

### GraphQLClient.ListTokenFlowsParams : `object`

Structure of GraphQLClient.ListTokenFlowsParams

Checkout the following snippet for the format of ListTokenFlowsParams:

```json
{
  "accountAddress": "abc",
  "tokenAddress": "abc",
  "depth": 123,
  "direction": "IN"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                    |
| -------------- | --------------------------------------- |
| accountAddress | `string`                                |
| tokenAddress   | `string`                                |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput) |
| depth          | `number`                                |
| ...direction   | `GraphQLClient.TokenFlowDirection`      |

### GraphQLClient.VerifyAccountRiskParams : `object`

Structure of GraphQLClient.VerifyAccountRiskParams

Checkout the following snippet for the format of VerifyAccountRiskParams:

```json
{
  "accountAddress": "abc",
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type     |
| -------------- | -------- |
| accountAddress | `string` |
| tokenAddress   | `string` |

### GraphQLClient.GetTokenDistributionParams : `object`

Structure of GraphQLClient.GetTokenDistributionParams

Checkout the following snippet for the format of GetTokenDistributionParams:

```json
{
  "tokenAddress": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name         | Type     |
| ------------ | -------- |
| tokenAddress | `string` |

### GraphQLClient.ListTokenFactoriesParams : `object`

Structure of GraphQLClient.ListTokenFactoriesParams

Checkout the following snippet for the format of ListTokenFactoriesParams:

```json
{
  "tokenAddress": "abc",
  "reserveAddress": "abc",
  "owner": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name           | Type                                                |
| -------------- | --------------------------------------------------- |
| tokenAddress   | `string`                                            |
| reserveAddress | `string`                                            |
| owner          | `string`                                            |
| ...paging      | [`PageInput`](#GraphQLClient.PageInput)             |
| ...timeFilter  | [`TimeFilterInput`](#GraphQLClient.TimeFilterInput) |

### GraphQLClient.SendTxParams : `object`

Structure of GraphQLClient.SendTxParams

Checkout the following snippet for the format of SendTxParams:

```json
{
  "commit": true,
  "token": "abc",
  "tx": "abc",
  "wallet": "abc",
  "extra": "abc"
}
```

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name   | Type      |
| ------ | --------- |
| commit | `boolean` |
| token  | `string`  |
| tx     | `string`  |
| wallet | `string`  |
| extra  | `string`  |

### GraphQLClient.AccountMigrateTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                  | Description                                                                                   |
| --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                              |                                                                                               |
| input.tx              | `object`                                              | data of the transaction                                                                       |
| input.tx.itx          | [`AccountMigrateTx`](#GraphQLClient.AccountMigrateTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                              | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                              | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                              | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                              | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                              | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                               | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                              | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                              | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.DelegateTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                      | Description                                                                                   |
| --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                  |                                                                                               |
| input.tx              | `object`                                  | data of the transaction                                                                       |
| input.tx.itx          | [`DelegateTx`](#GraphQLClient.DelegateTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                  | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                  | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                  | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                  | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                  | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                   | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                  | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                  | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.RevokeDelegateTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                  | Description                                                                                   |
| --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                              |                                                                                               |
| input.tx              | `object`                                              | data of the transaction                                                                       |
| input.tx.itx          | [`RevokeDelegateTx`](#GraphQLClient.RevokeDelegateTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                              | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                              | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                              | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                              | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                              | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                               | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                              | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                              | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.UpgradeNodeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`UpgradeNodeTx`](#GraphQLClient.UpgradeNodeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ExchangeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                      | Description                                                                                   |
| --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                  |                                                                                               |
| input.tx              | `object`                                  | data of the transaction                                                                       |
| input.tx.itx          | [`ExchangeTx`](#GraphQLClient.ExchangeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                  | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                  | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                  | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                  | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                  | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                   | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                  | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                  | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ExchangeV2TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`ExchangeV2Tx`](#GraphQLClient.ExchangeV2Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.TransferTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                      | Description                                                                                   |
| --------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                  |                                                                                               |
| input.tx              | `object`                                  | data of the transaction                                                                       |
| input.tx.itx          | [`TransferTx`](#GraphQLClient.TransferTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                  | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                  | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                  | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                  | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                  | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                   | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                  | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                  | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.TransferV2TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`TransferV2Tx`](#GraphQLClient.TransferV2Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.TransferV3TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`TransferV3Tx`](#GraphQLClient.TransferV3Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateTokenTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`CreateTokenTx`](#GraphQLClient.CreateTokenTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.AcquireAssetV2TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                  | Description                                                                                   |
| --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                              |                                                                                               |
| input.tx              | `object`                                              | data of the transaction                                                                       |
| input.tx.itx          | [`AcquireAssetV2Tx`](#GraphQLClient.AcquireAssetV2Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                              | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                              | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                              | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                              | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                              | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                               | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                              | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                              | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.AcquireAssetV3TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                  | Description                                                                                   |
| --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                              |                                                                                               |
| input.tx              | `object`                                              | data of the transaction                                                                       |
| input.tx.itx          | [`AcquireAssetV3Tx`](#GraphQLClient.AcquireAssetV3Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                              | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                              | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                              | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                              | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                              | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                               | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                              | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                              | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.MintAssetTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                        | Description                                                                                   |
| --------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                    |                                                                                               |
| input.tx              | `object`                                    | data of the transaction                                                                       |
| input.tx.itx          | [`MintAssetTx`](#GraphQLClient.MintAssetTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                    | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                    | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                    | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                    | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                    | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                     | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                    | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                    | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateAssetTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`CreateAssetTx`](#GraphQLClient.CreateAssetTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.UpdateAssetTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`UpdateAssetTx`](#GraphQLClient.UpdateAssetTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ConsumeAssetTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                              | Description                                                                                   |
| --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                          |                                                                                               |
| input.tx              | `object`                                          | data of the transaction                                                                       |
| input.tx.itx          | [`ConsumeAssetTx`](#GraphQLClient.ConsumeAssetTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                          | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                          | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                          | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                          | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                          | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                           | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                          | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                          | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateFactoryTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                | Description                                                                                   |
| --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                            |                                                                                               |
| input.tx              | `object`                                            | data of the transaction                                                                       |
| input.tx.itx          | [`CreateFactoryTx`](#GraphQLClient.CreateFactoryTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                            | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                            | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                            | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                            | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                            | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                             | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                            | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                            | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.StakeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                | Description                                                                                   |
| --------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                            |                                                                                               |
| input.tx              | `object`                            | data of the transaction                                                                       |
| input.tx.itx          | [`StakeTx`](#GraphQLClient.StakeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                            | the sender pk                                                                                 |
| [input.tx.from]       | `string`                            | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                            | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                            | the chainId                                                                                   |
| [input.tx.signature]  | `string`                            | transaction signature                                                                         |
| [input.tx.signatures] | `array`                             | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                            | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                            | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.RevokeStakeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`RevokeStakeTx`](#GraphQLClient.RevokeStakeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ClaimStakeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`ClaimStakeTx`](#GraphQLClient.ClaimStakeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.SlashStakeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`SlashStakeTx`](#GraphQLClient.SlashStakeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ReturnStakeTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`ReturnStakeTx`](#GraphQLClient.ReturnStakeTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                              | Description                                                                                   |
| --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                          |                                                                                               |
| input.tx              | `object`                                          | data of the transaction                                                                       |
| input.tx.itx          | [`CreateRollupTx`](#GraphQLClient.CreateRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                          | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                          | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                          | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                          | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                          | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                           | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                          | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                          | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.UpdateRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                              | Description                                                                                   |
| --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                          |                                                                                               |
| input.tx              | `object`                                          | data of the transaction                                                                       |
| input.tx.itx          | [`UpdateRollupTx`](#GraphQLClient.UpdateRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                          | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                          | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                          | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                          | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                          | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                           | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                          | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                          | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.JoinRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                          | Description                                                                                   |
| --------------------- | --------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                      |                                                                                               |
| input.tx              | `object`                                      | data of the transaction                                                                       |
| input.tx.itx          | [`JoinRollupTx`](#GraphQLClient.JoinRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.LeaveRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`LeaveRollupTx`](#GraphQLClient.LeaveRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateRollupBlockTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                        | Description                                                                                   |
| --------------------- | ----------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                                    |                                                                                               |
| input.tx              | `object`                                                    | data of the transaction                                                                       |
| input.tx.itx          | [`CreateRollupBlockTx`](#GraphQLClient.CreateRollupBlockTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                                    | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                                    | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                                    | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                                    | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                                    | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                                     | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                                    | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                                    | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ClaimBlockRewardTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                      | Description                                                                                   |
| --------------------- | --------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                                  |                                                                                               |
| input.tx              | `object`                                                  | data of the transaction                                                                       |
| input.tx.itx          | [`ClaimBlockRewardTx`](#GraphQLClient.ClaimBlockRewardTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                                  | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                                  | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                                  | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                                  | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                                  | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                                   | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                                  | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                                  | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.PauseRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`PauseRollupTx`](#GraphQLClient.PauseRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.ResumeRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                              | Description                                                                                   |
| --------------------- | ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                          |                                                                                               |
| input.tx              | `object`                                          | data of the transaction                                                                       |
| input.tx.itx          | [`ResumeRollupTx`](#GraphQLClient.ResumeRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                          | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                          | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                          | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                          | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                          | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                           | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                          | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                          | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CloseRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                            | Description                                                                                   |
| --------------------- | ----------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                        |                                                                                               |
| input.tx              | `object`                                        | data of the transaction                                                                       |
| input.tx.itx          | [`CloseRollupTx`](#GraphQLClient.CloseRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                        | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                        | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                        | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                        | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                        | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                         | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                        | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                        | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.MigrateRollupTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                | Description                                                                                   |
| --------------------- | --------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                            |                                                                                               |
| input.tx              | `object`                                            | data of the transaction                                                                       |
| input.tx.itx          | [`MigrateRollupTx`](#GraphQLClient.MigrateRollupTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                            | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                            | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                            | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                            | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                            | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                             | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                            | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                            | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.DepositTokenV2TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                  | Description                                                                                   |
| --------------------- | ----------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                              |                                                                                               |
| input.tx              | `object`                                              | data of the transaction                                                                       |
| input.tx.itx          | [`DepositTokenV2Tx`](#GraphQLClient.DepositTokenV2Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                              | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                              | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                              | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                              | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                              | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                               | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                              | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                              | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.WithdrawTokenV2TxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                    | Description                                                                                   |
| --------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                                |                                                                                               |
| input.tx              | `object`                                                | data of the transaction                                                                       |
| input.tx.itx          | [`WithdrawTokenV2Tx`](#GraphQLClient.WithdrawTokenV2Tx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                                | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                                | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                                | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                                | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                                | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                                 | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                                | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                                | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.CreateTokenFactoryTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                          | Description                                                                                   |
| --------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                                      |                                                                                               |
| input.tx              | `object`                                                      | data of the transaction                                                                       |
| input.tx.itx          | [`CreateTokenFactoryTx`](#GraphQLClient.CreateTokenFactoryTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.UpdateTokenFactoryTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                                          | Description                                                                                   |
| --------------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                                      |                                                                                               |
| input.tx              | `object`                                                      | data of the transaction                                                                       |
| input.tx.itx          | [`UpdateTokenFactoryTx`](#GraphQLClient.UpdateTokenFactoryTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                                      | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                                      | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                                      | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                                      | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                                      | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                                       | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                                      | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                                      | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.MintTokenTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                        | Description                                                                                   |
| --------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                    |                                                                                               |
| input.tx              | `object`                                    | data of the transaction                                                                       |
| input.tx.itx          | [`MintTokenTx`](#GraphQLClient.MintTokenTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                    | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                    | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                    | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                    | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                    | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                     | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                    | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                    | the signature of the tx, if this parameter exist, we will not sign the transaction            |

### GraphQLClient.BurnTokenTxInput : `Object`

**Kind**: static typedef of [`GraphQLClient`](#GraphQLClient)\
**Properties**

| Name                  | Type                                        | Description                                                                                   |
| --------------------- | ------------------------------------------- | --------------------------------------------------------------------------------------------- |
| input                 | `object`                                    |                                                                                               |
| input.tx              | `object`                                    | data of the transaction                                                                       |
| input.tx.itx          | [`BurnTokenTx`](#GraphQLClient.BurnTokenTx) | the actual transaction object                                                                 |
| [input.tx.pk]         | `string`                                    | the sender pk                                                                                 |
| [input.tx.from]       | `string`                                    | the sender address, can be derived from wallet                                                |
| [input.tx.nonce]      | `number`                                    | the tx nonce, defaults to Date.now if not set                                                 |
| [input.tx.chainId]    | `string`                                    | the chainId                                                                                   |
| [input.tx.signature]  | `string`                                    | transaction signature                                                                         |
| [input.tx.signatures] | `array`                                     | transaction signatures, should be set when it's a multisig transaction                        |
| input.wallet          | `object`                                    | the wallet used to sign the transaction, either a forge managed wallet or user managed wallet |
| [input.signature]     | `string`                                    | the signature of the tx, if this parameter exist, we will not sign the transaction            |