@ocap/client 1.18.8 → 1.18.10

package/dist/browser.d.ts

@@ -1,6 +1,9 @@
-import type { PartialDeep } from 'type-fest';
 import { WalletObject } from '@ocap/wallet';
 
+type PartialDeep<T> = {
+  [K in keyof T]?: T[K] extends object ? PartialDeep<T[K]> : T[K];
+};
+
 export as namespace GraphQLClient;
 
 /*~ This declaration specifies that the class constructor function
@@ -422,94 +425,113 @@ declare class GraphQLClient {
     param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateAssetTx>>
   ): Promise<GraphQLClient.Transaction>;
   getAccountState(
-    params: GraphQLClient.GetAccountStateParams
+    params: PartialDeep<GraphQLClient.GetAccountStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetAccountState>;
   getAssetState(
-    params: GraphQLClient.GetAssetStateParams
+    params: PartialDeep<GraphQLClient.GetAssetStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetAssetState>;
   getFactoryState(
-    params: GraphQLClient.GetFactoryStateParams
+    params: PartialDeep<GraphQLClient.GetFactoryStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetFactoryState>;
   getDelegateState(
-    params: GraphQLClient.GetDelegateStateParams
+    params: PartialDeep<GraphQLClient.GetDelegateStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetDelegateState>;
   getTokenState(
-    params: GraphQLClient.GetTokenStateParams
+    params: PartialDeep<GraphQLClient.GetTokenStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetTokenState>;
   getEvidenceState(
-    params: GraphQLClient.GetEvidenceStateParams
+    params: PartialDeep<GraphQLClient.GetEvidenceStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetEvidenceState>;
   getForgeState(
-    params: GraphQLClient.GetForgeStateParams
+    params: PartialDeep<GraphQLClient.GetForgeStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetForgeState>;
-  getTx(params: GraphQLClient.GetTxParams): GraphQLClient.QueryResult<GraphQLClient.ResponseGetTx>;
-  getBlock(params: GraphQLClient.GetBlockParams): GraphQLClient.QueryResult<GraphQLClient.ResponseGetBlock>;
-  getBlocks(params: GraphQLClient.GetBlocksParams): GraphQLClient.QueryResult<GraphQLClient.ResponseGetBlocks>;
+  getTx(params: PartialDeep<GraphQLClient.GetTxParams>): GraphQLClient.QueryResult<GraphQLClient.ResponseGetTx>;
+  getBlock(
+    params: PartialDeep<GraphQLClient.GetBlockParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetBlock>;
+  getBlocks(
+    params: PartialDeep<GraphQLClient.GetBlocksParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetBlocks>;
   getUnconfirmedTxs(
-    params: GraphQLClient.GetUnconfirmedTxsParams
+    params: PartialDeep<GraphQLClient.GetUnconfirmedTxsParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetUnconfirmedTxs>;
   getChainInfo(): GraphQLClient.QueryResult<GraphQLClient.ResponseGetChainInfo>;
-  getConfig(params: GraphQLClient.GetConfigParams): GraphQLClient.QueryResult<GraphQLClient.ResponseGetConfig>;
+  getConfig(
+    params: PartialDeep<GraphQLClient.GetConfigParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetConfig>;
   getNetInfo(): GraphQLClient.QueryResult<GraphQLClient.ResponseGetNetInfo>;
   getNodeInfo(): GraphQLClient.QueryResult<GraphQLClient.ResponseGetNodeInfo>;
   getValidatorsInfo(): GraphQLClient.QueryResult<GraphQLClient.ResponseGetValidatorsInfo>;
   getForgeStats(): GraphQLClient.QueryResult<GraphQLClient.ResponseGetForgeStats>;
   listAssetTransactions(
-    params: GraphQLClient.ListAssetTransactionsParams
+    params: PartialDeep<GraphQLClient.ListAssetTransactionsParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListAssetTransactions>;
-  listAssets(params: GraphQLClient.ListAssetsParams): GraphQLClient.QueryResult<GraphQLClient.ResponseListAssets>;
-  listBlocks(params: GraphQLClient.ListBlocksParams): GraphQLClient.QueryResult<GraphQLClient.ResponseListBlocks>;
+  listAssets(
+    params: PartialDeep<GraphQLClient.ListAssetsParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseListAssets>;
+  listBlocks(
+    params: PartialDeep<GraphQLClient.ListBlocksParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseListBlocks>;
   listTopAccounts(
-    params: GraphQLClient.ListTopAccountsParams
+    params: PartialDeep<GraphQLClient.ListTopAccountsParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListTopAccounts>;
   listTransactions(
-    params: GraphQLClient.ListTransactionsParams
+    params: PartialDeep<GraphQLClient.ListTransactionsParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListTransactions>;
-  listTokens(params: GraphQLClient.ListTokensParams): GraphQLClient.QueryResult<GraphQLClient.ResponseListTokens>;
+  listTokens(
+    params: PartialDeep<GraphQLClient.ListTokensParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseListTokens>;
   listFactories(
-    params: GraphQLClient.ListFactoriesParams
+    params: PartialDeep<GraphQLClient.ListFactoriesParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListFactories>;
   getAccountTokens(
-    params: GraphQLClient.GetAccountTokensParams
+    params: PartialDeep<GraphQLClient.GetAccountTokensParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetAccountTokens>;
   getStakeState(
-    params: GraphQLClient.GetStakeStateParams
+    params: PartialDeep<GraphQLClient.GetStakeStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetStakeState>;
-  listStakes(params: GraphQLClient.ListStakesParams): GraphQLClient.QueryResult<GraphQLClient.ResponseListStakes>;
+  listStakes(
+    params: PartialDeep<GraphQLClient.ListStakesParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseListStakes>;
   getRollupState(
-    params: GraphQLClient.GetRollupStateParams
+    params: PartialDeep<GraphQLClient.GetRollupStateParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetRollupState>;
-  listRollups(params: GraphQLClient.ListRollupsParams): GraphQLClient.QueryResult<GraphQLClient.ResponseListRollups>;
+  listRollups(
+    params: PartialDeep<GraphQLClient.ListRollupsParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseListRollups>;
   getRollupBlock(
-    params: GraphQLClient.GetRollupBlockParams
+    params: PartialDeep<GraphQLClient.GetRollupBlockParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetRollupBlock>;
   listRollupBlocks(
-    params: GraphQLClient.ListRollupBlocksParams
+    params: PartialDeep<GraphQLClient.ListRollupBlocksParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListRollupBlocks>;
   listRollupValidators(
-    params: GraphQLClient.ListRollupValidatorsParams
+    params: PartialDeep<GraphQLClient.ListRollupValidatorsParams>
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseListRollupValidators>;
-  search(params: GraphQLClient.SearchParams): GraphQLClient.QueryResult<GraphQLClient.ResponseSearch>;
-  sendTx(params: GraphQLClient.SendTxParams): GraphQLClient.QueryResult<GraphQLClient.ResponseSendTx>;
+  search(params: PartialDeep<GraphQLClient.SearchParams>): GraphQLClient.QueryResult<GraphQLClient.ResponseSearch>;
+  estimateGas(
+    params: PartialDeep<GraphQLClient.EstimateGasParams>
+  ): GraphQLClient.QueryResult<GraphQLClient.ResponseEstimateGas>;
+  sendTx(params: PartialDeep<GraphQLClient.SendTxParams>): GraphQLClient.QueryResult<GraphQLClient.ResponseSendTx>;
 }
 
 declare namespace GraphQLClient {
-  export interface QueryResult<T> {
+  interface QueryResult<T> {
     then(fn: (result: T) => any): Promise<any>;
     catch(fn: (err: Error) => any): Promise<any>;
   }
 
-  export interface SubscriptionResult<T> {
+  interface SubscriptionResult<T> {
     then(fn: (result: GraphQLClient.Subscription<T>) => any): Promise<any>;
     catch(fn: (err: Error) => any): Promise<any>;
   }
 
-  export interface Subscription<T> {
+  interface Subscription<T> {
     on(event: 'data', fn: (data: T) => any): this;
     on(event: 'error', fn: (err: Error) => void): this;
   }
 
-  export interface TxParam<T> {
+  interface TxParam<T> {
     tx: {
       nonce?: number;
       from?: string;
@@ -517,7 +539,7 @@ declare namespace GraphQLClient {
       chainId?: string;
       delegator?: string;
       signature?: string;
-      signatures?: GraphQLClient.Multisig;
+      signatures?: PartialDeep<GraphQLClient.Multisig>[];
       itx: T;
     };
     wallet: WalletObject;
@@ -525,30 +547,30 @@ declare namespace GraphQLClient {
     signature?: string;
   }
 
-  export interface WalletTypeObject {
+  interface WalletTypeObject {
     pk: number;
     role: number;
     address: number;
     hash: number;
   }
 
-  export interface EncodeTxResult {
+  interface EncodeTxResult {
     object: object;
     buffer: buffer;
   }
 
-  export enum Direction {
+  enum Direction {
     MUTUAL,
     ONE_WAY,
     UNION,
   }
 
-  export enum EncodingType {
+  enum EncodingType {
     BASE16,
     BASE58,
   }
 
-  export enum HashType {
+  enum HashType {
     KECCAK,
     SHA3,
     SHA2,
@@ -558,13 +580,13 @@ declare namespace GraphQLClient {
     SHA3_512,
   }
 
-  export enum KeyType {
+  enum KeyType {
     ED25519,
     SECP256K1,
     ETHEREUM,
   }
 
-  export enum RoleType {
+  enum RoleType {
     ROLE_ACCOUNT,
     ROLE_NODE,
     ROLE_DEVICE,
@@ -589,7 +611,7 @@ declare namespace GraphQLClient {
     ROLE_ANY,
   }
 
-  export enum StatusCode {
+  enum StatusCode {
     OK,
     INVALID_NONCE,
     INVALID_SIGNATURE,
@@ -667,7 +689,7 @@ declare namespace GraphQLClient {
     TIMEOUT,
   }
 
-  export enum UpgradeAction {
+  enum UpgradeAction {
     VERIFY,
     BACKUP,
     REPLACE,
@@ -682,7 +704,7 @@ declare namespace GraphQLClient {
     DROP_ADDRESS_BOOK,
   }
 
-  export enum UpgradeType {
+  enum UpgradeType {
     CONFIG_APP,
     CONFIG_FORGE,
     CONFIG_DFS,
@@ -695,100 +717,239 @@ declare namespace GraphQLClient {
     EXE_P2P,
   }
 
-  export enum Validity {
+  enum Validity {
     BOTH,
     VALID,
     INVALID,
   }
 
-  export interface AccountFilterInput {}
+  interface AccountFilterInput {
+    accounts: string[];
+  }
 
-  export interface AddressFilterInput {}
+  interface AddressFilterInput {
+    sender: string;
+    receiver: string;
+    direction: GraphQLClient.Direction;
+  }
 
-  export interface AssetFilterInput {}
+  interface AssetFilterInput {
+    assets: string[];
+  }
 
-  export interface FactoryFilterInput {}
+  interface FactoryFilterInput {
+    factories: string[];
+  }
 
-  export interface PageInput {}
+  interface PageInput {
+    cursor: string;
+    size: number;
+    order: GraphQLClient.PageOrderInput[];
+  }
 
-  export interface PageOrderInput {}
+  interface PageOrderInput {
+    field: string;
+    type: string;
+  }
 
-  export interface RangeFilterInput {}
+  interface RangeFilterInput {
+    from: string;
+    to: string;
+  }
 
-  export interface RequestGetAccountTokensInput {}
+  interface RequestEstimateGasInput {
+    typeUrl: string;
+    tx: string;
+  }
 
-  export interface RequestGetBlockInput {}
+  interface RequestGetAccountTokensInput {
+    address: string;
+    token: string;
+  }
+
+  interface RequestGetBlockInput {
+    height: number;
+  }
 
-  export interface RequestGetBlocksInput {}
+  interface RequestGetBlocksInput {
+    paging: GraphQLClient.PageInput;
+    heightFilter: GraphQLClient.RangeFilterInput;
+    emptyExcluded: boolean;
+  }
 
-  export interface RequestGetConfigInput {}
+  interface RequestGetConfigInput {
+    parsed: boolean;
+  }
 
-  export interface RequestGetEvidenceStateInput {}
+  interface RequestGetEvidenceStateInput {
+    hash: string;
+  }
 
-  export interface RequestGetRollupBlockInput {}
+  interface RequestGetRollupBlockInput {
+    hash: string;
+    height: number;
+    rollupAddress: string;
+  }
 
-  export interface RequestGetStateInput {}
+  interface RequestGetStateInput {
+    address: string;
+    keys: string[];
+    height: number;
+  }
 
-  export interface RequestGetTxInput {}
+  interface RequestGetTxInput {
+    hash: string;
+  }
 
-  export interface RequestListAssetTransactionsInput {}
+  interface RequestListAssetTransactionsInput {
+    paging: GraphQLClient.PageInput;
+    address: string;
+  }
 
-  export interface RequestListAssetsInput {}
+  interface RequestListAssetsInput {
+    paging: GraphQLClient.PageInput;
+    ownerAddress: string;
+    factoryAddress: string;
+    timeFilter: GraphQLClient.TimeFilterInput;
+  }
 
-  export interface RequestListBlocksInput {}
+  interface RequestListBlocksInput {
+    paging: GraphQLClient.PageInput;
+    proposer: string;
+    timeFilter: GraphQLClient.TimeFilterInput;
+    heightFilter: GraphQLClient.RangeFilterInput;
+    numTxsFilter: GraphQLClient.RangeFilterInput;
+    numInvalidTxsFilter: GraphQLClient.RangeFilterInput;
+  }
 
-  export interface RequestListFactoriesInput {}
+  interface RequestListFactoriesInput {
+    paging: GraphQLClient.PageInput;
+    ownerAddress: string;
+    addressList: string[];
+  }
 
-  export interface RequestListRollupBlocksInput {}
+  interface RequestListRollupBlocksInput {
+    paging: GraphQLClient.PageInput;
+    rollupAddress: string;
+    tokenAddress: string;
+    proposer: string;
+    validatorFilter: GraphQLClient.ValidatorFilterInput;
+    txFilter: GraphQLClient.TxFilterInput;
+    timeFilter: GraphQLClient.TimeFilterInput;
+  }
 
-  export interface RequestListRollupValidatorsInput {}
+  interface RequestListRollupValidatorsInput {
+    paging: GraphQLClient.PageInput;
+    rollupAddress: string;
+  }
 
-  export interface RequestListRollupsInput {}
+  interface RequestListRollupsInput {
+    paging: GraphQLClient.PageInput;
+    tokenAddress: string;
+    foreignTokenAddress: string;
+  }
 
-  export interface RequestListStakesInput {}
+  interface RequestListStakesInput {
+    paging: GraphQLClient.PageInput;
+    addressFilter: GraphQLClient.AddressFilterInput;
+    timeFilter: GraphQLClient.TimeFilterInput;
+    assetFilter: GraphQLClient.AssetFilterInput;
+  }
 
-  export interface RequestListTokensInput {}
+  interface RequestListTokensInput {
+    paging: GraphQLClient.PageInput;
+    issuerAddress: string;
+  }
 
-  export interface RequestListTopAccountsInput {}
+  interface RequestListTopAccountsInput {
+    paging: GraphQLClient.PageInput;
+    tokenAddress: string;
+  }
 
-  export interface RequestListTransactionsInput {}
+  interface RequestListTransactionsInput {
+    paging: GraphQLClient.PageInput;
+    timeFilter: GraphQLClient.TimeFilterInput;
+    addressFilter: GraphQLClient.AddressFilterInput;
+    typeFilter: GraphQLClient.TypeFilterInput;
+    validityFilter: GraphQLClient.ValidityFilterInput;
+    factoryFilter: GraphQLClient.FactoryFilterInput;
+    tokenFilter: GraphQLClient.TokenFilterInput;
+    assetFilter: GraphQLClient.AssetFilterInput;
+    accountFilter: GraphQLClient.AccountFilterInput;
+    txFilter: GraphQLClient.TxFilterInput;
+    rollupFilter: GraphQLClient.RollupFilterInput;
+  }
 
-  export interface RequestSearchInput {}
+  interface RequestSearchInput {
+    paging: GraphQLClient.PageInput;
+    keyword: string;
+  }
 
-  export interface RequestSendTxInput {}
+  interface RequestSendTxInput {
+    tx: string;
+    wallet: GraphQLClient.WalletInfoInput;
+    token: string;
+    commit: boolean;
+  }
 
-  export interface RollupFilterInput {}
+  interface RollupFilterInput {
+    rollups: string[];
+  }
 
-  export interface TimeFilterInput {}
+  interface TimeFilterInput {
+    startDateTime: string;
+    endDateTime: string;
+    field: string;
+  }
 
-  export interface TokenFilterInput {}
+  interface TokenFilterInput {
+    tokens: string[];
+  }
 
-  export interface TxFilterInput {}
+  interface TxFilterInput {
+    txs: string[];
+  }
 
-  export interface TypeFilterInput {}
+  interface TypeFilterInput {
+    types: string[];
+  }
 
-  export interface ValidatorFilterInput {}
+  interface ValidatorFilterInput {
+    validators: string[];
+  }
 
-  export interface ValidityFilterInput {}
+  interface ValidityFilterInput {
+    validity: GraphQLClient.Validity;
+  }
 
-  export interface WalletInfoInput {}
+  interface WalletInfoInput {
+    type: GraphQLClient.WalletTypeInput;
+    sk: string;
+    pk: string;
+    address: string;
+  }
 
-  export interface WalletTypeInput {}
+  interface WalletTypeInput {
+    pk: GraphQLClient.KeyType;
+    hash: GraphQLClient.HashType;
+    address: GraphQLClient.EncodingType;
+    role: GraphQLClient.RoleType;
+  }
 
-  export interface AccountConfig {
+  interface AccountConfig {
     address: string;
     pk: string;
     balance: string;
   }
 
-  export interface AccountMigrateTx {
+  interface AccountMigrateTx {
     pk: string;
     type: GraphQLClient.WalletType;
     address: string;
     data: GraphQLClient.Any;
   }
 
-  export interface AccountState {
+  interface AccountState {
     balance: string;
     nonce: string;
     numTxs: string;
@@ -799,78 +960,78 @@ declare namespace GraphQLClient {
     context: GraphQLClient.StateContext;
     issuer: string;
     gasBalance: string;
-    migratedTo: Array<string>;
-    migratedFrom: Array<string>;
+    migratedTo: string[];
+    migratedFrom: string[];
     numAssets: string;
-    tokens: Array<GraphQLClient.IndexedTokenInput>;
+    tokens: GraphQLClient.IndexedTokenInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface AccountToken {
+  interface AccountToken {
     address: string;
     symbol: string;
     balance: string;
     decimal: number;
   }
 
-  export interface AcquireAssetV2Tx {
+  interface AcquireAssetV2Tx {
     factory: string;
     address: string;
-    assets: Array<string>;
-    variables: Array<GraphQLClient.VariableInput>;
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
     issuer: GraphQLClient.NFTIssuer;
     data: GraphQLClient.Any;
   }
 
-  export interface AcquireAssetV3Tx {
+  interface AcquireAssetV3Tx {
     factory: string;
     address: string;
-    inputs: Array<GraphQLClient.TransactionInput>;
+    inputs: GraphQLClient.TransactionInput[];
     owner: string;
-    variables: Array<GraphQLClient.VariableInput>;
+    variables: GraphQLClient.VariableInput[];
     issuer: GraphQLClient.NFTIssuer;
     data: GraphQLClient.Any;
   }
 
-  export interface Any {
+  interface Any {
     typeUrl: string;
     value: string;
   }
 
-  export interface AssetFactoryHook {
+  interface AssetFactoryHook {
     name: string;
     type: string;
     hook: string;
   }
 
-  export interface AssetFactoryInput {
+  interface AssetFactoryInput {
     value: string;
-    tokens: Array<GraphQLClient.TokenInput>;
-    assets: Array<string>;
-    variables: Array<GraphQLClient.VariableInput>;
+    tokens: GraphQLClient.TokenInput[];
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
   }
 
-  export interface AssetFactoryState {
+  interface AssetFactoryState {
     address: string;
     owner: string;
     name: string;
     description: string;
     settlement: string;
     limit: number;
-    trustedIssuers: Array<string>;
+    trustedIssuers: string[];
     input: GraphQLClient.IndexedFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<GraphQLClient.AssetFactoryHook>;
+    hooks: GraphQLClient.AssetFactoryHook[];
     data: GraphQLClient.Any;
     context: GraphQLClient.StateContext;
     balance: string;
-    tokens: Array<GraphQLClient.IndexedTokenInput>;
+    tokens: GraphQLClient.IndexedTokenInput[];
     numMinted: number;
     display: GraphQLClient.NFTDisplay;
     lastSettlement: string;
   }
 
-  export interface AssetState {
+  interface AssetState {
     address: string;
     owner: string;
     moniker: string;
@@ -882,27 +1043,27 @@ declare namespace GraphQLClient {
     parent: string;
     endpoint: GraphQLClient.NFTEndpoint;
     display: GraphQLClient.NFTDisplay;
-    tags: Array<string>;
+    tags: string[];
     context: GraphQLClient.StateContext;
     data: GraphQLClient.Any;
   }
 
-  export interface BlockID {
+  interface BlockID {
     hash: string;
     partsHeader: GraphQLClient.PartSetHeader;
   }
 
-  export interface BlockInfo {
+  interface BlockInfo {
     height: string;
     numTxs: number;
     time: string;
     appHash: string;
     proposer: string;
-    txs: Array<GraphQLClient.TransactionInfo>;
+    txs: GraphQLClient.TransactionInfo[];
     totalTxs: string;
-    invalidTxs: Array<GraphQLClient.TransactionInfo>;
-    txsHashes: Array<string>;
-    invalidTxsHashes: Array<string>;
+    invalidTxs: GraphQLClient.TransactionInfo[];
+    txsHashes: string[];
+    invalidTxsHashes: string[];
     consensusHash: string;
     dataHash: string;
     evidenceHash: string;
@@ -914,15 +1075,15 @@ declare namespace GraphQLClient {
     lastBlockId: GraphQLClient.BlockID;
   }
 
-  export interface BlockInfoSimple {
+  interface BlockInfoSimple {
     height: string;
     numTxs: number;
     time: string;
     appHash: string;
     proposer: string;
     totalTxs: string;
-    txsHashes: Array<string>;
-    invalidTxsHashes: Array<string>;
+    txsHashes: string[];
+    invalidTxsHashes: string[];
     consensusHash: string;
     dataHash: string;
     evidenceHash: string;
@@ -934,7 +1095,7 @@ declare namespace GraphQLClient {
     lastBlockId: GraphQLClient.BlockID;
   }
 
-  export interface ChainInfo {
+  interface ChainInfo {
     id: string;
     network: string;
     moniker: string;
@@ -948,16 +1109,16 @@ declare namespace GraphQLClient {
     votingPower: string;
     totalTxs: string;
     version: string;
-    forgeAppsVersion: Array<GraphQLClient.ChainInfo_ForgeAppsVersionEntry>;
-    supportedTxs: Array<string>;
+    forgeAppsVersion: GraphQLClient.ChainInfo_ForgeAppsVersionEntry[];
+    supportedTxs: string[];
   }
 
-  export interface ChainInfo_ForgeAppsVersionEntry {
+  interface ChainInfo_ForgeAppsVersionEntry {
     key: string;
     value: string;
   }
 
-  export interface ClaimBlockRewardTx {
+  interface ClaimBlockRewardTx {
     rollup: string;
     blockHeight: number;
     blockHash: string;
@@ -966,24 +1127,24 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ClaimStakeTx {
+  interface ClaimStakeTx {
     address: string;
     evidence: GraphQLClient.Evidence;
     data: GraphQLClient.Any;
   }
 
-  export interface ConsensusParams {
+  interface ConsensusParams {
     maxBytes: string;
     maxGas: string;
     maxValidators: number;
     maxCandidates: number;
-    pubKeyTypes: Array<string>;
-    validators: Array<GraphQLClient.Validator>;
+    pubKeyTypes: string[];
+    validators: GraphQLClient.Validator[];
     validatorChanged: boolean;
     paramChanged: boolean;
   }
 
-  export interface CreateAssetTx {
+  interface CreateAssetTx {
     moniker: string;
     data: GraphQLClient.Any;
     readonly: boolean;
@@ -994,42 +1155,42 @@ declare namespace GraphQLClient {
     issuer: string;
     endpoint: GraphQLClient.NFTEndpoint;
     display: GraphQLClient.NFTDisplay;
-    tags: Array<string>;
+    tags: string[];
   }
 
-  export interface CreateFactoryTx {
+  interface CreateFactoryTx {
     name: string;
     description: string;
     settlement: string;
     limit: number;
-    trustedIssuers: Array<string>;
+    trustedIssuers: string[];
     input: GraphQLClient.AssetFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<GraphQLClient.AssetFactoryHook>;
+    hooks: GraphQLClient.AssetFactoryHook[];
     address: string;
     display: GraphQLClient.NFTDisplay;
     data: GraphQLClient.Any;
   }
 
-  export interface CreateRollupBlockTx {
+  interface CreateRollupBlockTx {
     hash: string;
     height: number;
     merkleRoot: string;
     previousHash: string;
     txsHash: string;
-    txs: Array<string>;
+    txs: string[];
     proposer: string;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     rollup: string;
     minReward: string;
     data: GraphQLClient.Any;
   }
 
-  export interface CreateRollupTx {
+  interface CreateRollupTx {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<GraphQLClient.RollupValidator>;
+    seedValidators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -1059,7 +1220,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface CreateTokenTx {
+  interface CreateTokenTx {
     name: string;
     description: string;
     symbol: string;
@@ -1073,23 +1234,23 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface DeclareTx {
+  interface DeclareTx {
     moniker: string;
     issuer: string;
     data: GraphQLClient.Any;
   }
 
-  export interface DelegateConfig {
+  interface DelegateConfig {
     deltaInterval: number;
-    typeUrls: Array<string>;
+    typeUrls: string[];
   }
 
-  export interface DelegateOp {
+  interface DelegateOp {
     typeUrl: string;
-    rules: Array<string>;
+    rules: string[];
   }
 
-  export interface DelegateOpState {
+  interface DelegateOpState {
     rule: string;
     numTxs: number;
     numTxsDelta: number;
@@ -1097,26 +1258,26 @@ declare namespace GraphQLClient {
     balanceDelta: string;
   }
 
-  export interface DelegateState {
+  interface DelegateState {
     address: string;
-    ops: Array<GraphQLClient.DelegateState_OpsEntry>;
+    ops: GraphQLClient.DelegateState_OpsEntry[];
     context: GraphQLClient.StateContext;
     data: GraphQLClient.Any;
   }
 
-  export interface DelegateState_OpsEntry {
+  interface DelegateState_OpsEntry {
     key: string;
     value: GraphQLClient.DelegateOpState;
   }
 
-  export interface DelegateTx {
+  interface DelegateTx {
     address: string;
     to: string;
-    ops: Array<GraphQLClient.DelegateOp>;
+    ops: GraphQLClient.DelegateOp[];
     data: GraphQLClient.Any;
   }
 
-  export interface DepositTokenV2Tx {
+  interface DepositTokenV2Tx {
     token: GraphQLClient.TokenInput;
     to: string;
     proposer: string;
@@ -1126,28 +1287,28 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface Evidence {
+  interface Evidence {
     hash: string;
   }
 
-  export interface EvidenceState {
+  interface EvidenceState {
     hash: string;
     data: string;
     context: GraphQLClient.StateContext;
   }
 
-  export interface ExchangeInfo {
+  interface ExchangeInfo {
     value: string;
-    assets: Array<string>;
+    assets: string[];
   }
 
-  export interface ExchangeInfoV2 {
+  interface ExchangeInfoV2 {
     value: string;
-    assets: Array<string>;
-    tokens: Array<GraphQLClient.TokenInput>;
+    assets: string[];
+    tokens: GraphQLClient.TokenInput[];
   }
 
-  export interface ExchangeTx {
+  interface ExchangeTx {
     to: string;
     sender: GraphQLClient.ExchangeInfo;
     receiver: GraphQLClient.ExchangeInfo;
@@ -1155,7 +1316,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ExchangeV2Tx {
+  interface ExchangeV2Tx {
     to: string;
     sender: GraphQLClient.ExchangeInfoV2;
     receiver: GraphQLClient.ExchangeInfoV2;
@@ -1163,7 +1324,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ForeignToken {
+  interface ForeignToken {
     type: string;
     contractAddress: string;
     chainType: string;
@@ -1171,46 +1332,46 @@ declare namespace GraphQLClient {
     chainId: number;
   }
 
-  export interface ForgeState {
+  interface ForgeState {
     address: string;
     consensus: GraphQLClient.ConsensusParams;
-    tasks: Array<GraphQLClient.ForgeState_TasksEntry>;
+    tasks: GraphQLClient.ForgeState_TasksEntry[];
     version: string;
     token: GraphQLClient.ForgeToken;
     txConfig: GraphQLClient.TransactionConfig;
     upgradeInfo: GraphQLClient.UpgradeInfo;
-    accountConfig: Array<GraphQLClient.AccountConfig>;
+    accountConfig: GraphQLClient.AccountConfig[];
     data: GraphQLClient.Any;
   }
 
-  export interface ForgeState_TasksEntry {
+  interface ForgeState_TasksEntry {
     key: number;
     value: GraphQLClient.UpgradeTasks;
   }
 
-  export interface ForgeStats {
-    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>;
+  interface ForgeStats {
+    numBlocks: string[];
+    numTxs: string[];
+    numStakes: string[];
+    numValidators: number[];
+    numAccountMigrateTxs: string[];
+    numCreateAssetTxs: string[];
+    numConsensusUpgradeTxs: number[];
+    numDeclareTxs: string[];
+    numDeclareFileTxs: string[];
+    numExchangeTxs: string[];
+    numStakeTxs: string[];
+    numSysUpgradeTxs: number[];
+    numTransferTxs: string[];
+    numUpdateAssetTxs: string[];
+    numConsumeAssetTxs: string[];
+    tps: number[];
     maxTps: number;
     avgTps: number;
     avgBlockTime: number;
   }
 
-  export interface ForgeToken {
+  interface ForgeToken {
     name: string;
     symbol: string;
     unit: string;
@@ -1223,14 +1384,18 @@ declare namespace GraphQLClient {
     address: string;
   }
 
-  export interface GeoInfo {
+  interface GasEstimate {
+    max: string;
+  }
+
+  interface GeoInfo {
     city: string;
     country: string;
     latitude: number;
     longitude: number;
   }
 
-  export interface IndexedAccountState {
+  interface IndexedAccountState {
     address: string;
     balance: string;
     numAssets: string;
@@ -1244,11 +1409,11 @@ declare namespace GraphQLClient {
     totalReceivedStakes: string;
     totalStakes: string;
     totalUnstakes: string;
-    recentNumTxs: Array<string>;
-    tokens: Array<GraphQLClient.TokenInfo>;
+    recentNumTxs: string[];
+    tokens: GraphQLClient.TokenInfo[];
   }
 
-  export interface IndexedAssetState {
+  interface IndexedAssetState {
     address: string;
     owner: string;
     genesisTime: string;
@@ -1262,11 +1427,11 @@ declare namespace GraphQLClient {
     ttl: string;
     display: GraphQLClient.NFTDisplay;
     endpoint: GraphQLClient.NFTEndpoint;
-    tags: Array<string>;
+    tags: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedBlock {
+  interface IndexedBlock {
     height: string;
     time: string;
     proposer: string;
@@ -1274,27 +1439,27 @@ declare namespace GraphQLClient {
     numInvalidTxs: string;
   }
 
-  export interface IndexedFactoryInput {
+  interface IndexedFactoryInput {
     value: string;
-    tokens: Array<GraphQLClient.IndexedTokenInput>;
-    assets: Array<string>;
-    variables: Array<GraphQLClient.VariableInput>;
+    tokens: GraphQLClient.IndexedTokenInput[];
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
   }
 
-  export interface IndexedFactoryState {
+  interface IndexedFactoryState {
     address: string;
     owner: string;
     name: string;
     description: string;
     settlement: string;
     limit: string;
-    trustedIssuers: Array<string>;
+    trustedIssuers: string[];
     input: GraphQLClient.IndexedFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<GraphQLClient.AssetFactoryHook>;
+    hooks: GraphQLClient.AssetFactoryHook[];
     data: GraphQLClient.Any;
     balance: string;
-    tokens: Array<GraphQLClient.TokenInfo>;
+    tokens: GraphQLClient.TokenInfo[];
     numMinted: number;
     lastSettlement: string;
     genesisTime: string;
@@ -1302,15 +1467,15 @@ declare namespace GraphQLClient {
     display: GraphQLClient.NFTDisplay;
   }
 
-  export interface IndexedRollupBlock {
+  interface IndexedRollupBlock {
     hash: string;
     height: number;
     merkleRoot: string;
     previousHash: string;
     txsHash: string;
-    txs: Array<string>;
+    txs: string[];
     proposer: string;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     genesisTime: string;
     renaissanceTime: string;
     rollup: string;
@@ -1321,12 +1486,12 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedRollupState {
+  interface IndexedRollupState {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<GraphQLClient.RollupValidator>;
-    validators: Array<GraphQLClient.RollupValidator>;
+    seedValidators: GraphQLClient.RollupValidator[];
+    validators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -1360,11 +1525,11 @@ declare namespace GraphQLClient {
     publisherFeeShare: number;
     publishWaitingPeriod: number;
     publishSlashRate: number;
-    migrateHistory: Array<string>;
+    migrateHistory: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedRollupValidator {
+  interface IndexedRollupValidator {
     pk: string;
     address: string;
     moniker: string;
@@ -1384,23 +1549,23 @@ declare namespace GraphQLClient {
     rollup: string;
   }
 
-  export interface IndexedStakeState {
+  interface IndexedStakeState {
     address: string;
     sender: string;
     receiver: string;
-    tokens: Array<GraphQLClient.TokenInfo>;
-    assets: Array<string>;
+    tokens: GraphQLClient.TokenInfo[];
+    assets: string[];
     revocable: boolean;
     genesisTime: string;
     renaissanceTime: string;
     message: string;
     revokeWaitingPeriod: number;
-    revokedTokens: Array<GraphQLClient.TokenInfo>;
-    revokedAssets: Array<string>;
+    revokedTokens: GraphQLClient.TokenInfo[];
+    revokedAssets: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedTokenInput {
+  interface IndexedTokenInput {
     address: string;
     value: string;
     decimal: number;
@@ -1408,7 +1573,7 @@ declare namespace GraphQLClient {
     symbol: string;
   }
 
-  export interface IndexedTokenState {
+  interface IndexedTokenState {
     name: string;
     description: string;
     symbol: string;
@@ -1424,7 +1589,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedTransaction {
+  interface IndexedTransaction {
     hash: string;
     sender: string;
     receiver: string;
@@ -1433,37 +1598,37 @@ declare namespace GraphQLClient {
     tx: GraphQLClient.Transaction;
     valid: boolean;
     code: string;
-    tokenSymbols: Array<GraphQLClient.TokenSymbol>;
-    receipts: Array<GraphQLClient.TransactionReceipt>;
+    tokenSymbols: GraphQLClient.TokenSymbol[];
+    receipts: GraphQLClient.TransactionReceipt[];
   }
 
-  export interface JoinRollupTx {
+  interface JoinRollupTx {
     rollup: string;
     endpoint: string;
     evidence: GraphQLClient.Evidence;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     data: GraphQLClient.Any;
   }
 
-  export interface KVPair {
+  interface KVPair {
     key: string;
     value: string;
   }
 
-  export interface LeaveRollupTx {
+  interface LeaveRollupTx {
     rollup: string;
     evidence: GraphQLClient.Evidence;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     data: GraphQLClient.Any;
   }
 
-  export interface MigrateRollupContractTx {
+  interface MigrateRollupContractTx {
     rollup: string;
     to: string;
     data: GraphQLClient.Any;
   }
 
-  export interface MigrateRollupTokenTx {
+  interface MigrateRollupTokenTx {
     rollup: string;
     from: string;
     to: string;
@@ -1471,16 +1636,16 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface MintAssetTx {
+  interface MintAssetTx {
     factory: string;
     address: string;
-    assets: Array<string>;
-    variables: Array<GraphQLClient.VariableInput>;
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
     owner: string;
     data: GraphQLClient.Any;
   }
 
-  export interface Multisig {
+  interface Multisig {
     signer: string;
     pk: string;
     signature: string;
@@ -1488,30 +1653,30 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface NFTDisplay {
+  interface NFTDisplay {
     type: string;
     content: string;
   }
 
-  export interface NFTEndpoint {
+  interface NFTEndpoint {
     id: string;
     scope: string;
   }
 
-  export interface NFTIssuer {
+  interface NFTIssuer {
     id: string;
     pk: string;
     name: string;
   }
 
-  export interface NetInfo {
+  interface NetInfo {
     listening: boolean;
-    listeners: Array<string>;
+    listeners: string[];
     nPeers: number;
-    peers: Array<GraphQLClient.PeerInfo>;
+    peers: GraphQLClient.PeerInfo[];
   }
 
-  export interface NodeInfo {
+  interface NodeInfo {
     id: string;
     network: string;
     moniker: string;
@@ -1525,35 +1690,35 @@ declare namespace GraphQLClient {
     votingPower: string;
     totalTxs: string;
     version: string;
-    forgeAppsVersion: Array<GraphQLClient.NodeInfo_ForgeAppsVersionEntry>;
-    supportedTxs: Array<string>;
+    forgeAppsVersion: GraphQLClient.NodeInfo_ForgeAppsVersionEntry[];
+    supportedTxs: string[];
     ip: string;
     geoInfo: GraphQLClient.GeoInfo;
     p2pAddress: string;
   }
 
-  export interface NodeInfo_ForgeAppsVersionEntry {
+  interface NodeInfo_ForgeAppsVersionEntry {
     key: string;
     value: string;
   }
 
-  export interface PageInfo {
+  interface PageInfo {
     cursor: string;
     next: boolean;
     total: number;
   }
 
-  export interface PartSetHeader {
+  interface PartSetHeader {
     total: number;
     hash: string;
   }
 
-  export interface PauseRollupTx {
+  interface PauseRollupTx {
     rollup: string;
     data: GraphQLClient.Any;
   }
 
-  export interface PeerInfo {
+  interface PeerInfo {
     id: string;
     network: string;
     consensusVersion: string;
@@ -1562,228 +1727,233 @@ declare namespace GraphQLClient {
     geoInfo: GraphQLClient.GeoInfo;
   }
 
-  export interface PubKey {
+  interface PubKey {
     type: string;
     data: string;
   }
 
-  export interface ReceiptChange {
+  interface ReceiptChange {
     target: string;
     action: string;
     value: string;
   }
 
-  export interface ResponseGetAccountState {
+  interface ResponseEstimateGas {
+    code: string;
+    estimate: GraphQLClient.GasEstimate;
+  }
+
+  interface ResponseGetAccountState {
     code: string;
     state: GraphQLClient.AccountState;
   }
 
-  export interface ResponseGetAccountTokens {
+  interface ResponseGetAccountTokens {
     code: string;
-    tokens: Array<GraphQLClient.AccountToken>;
+    tokens: GraphQLClient.AccountToken[];
   }
 
-  export interface ResponseGetAssetState {
+  interface ResponseGetAssetState {
     code: string;
     state: GraphQLClient.AssetState;
   }
 
-  export interface ResponseGetBlock {
+  interface ResponseGetBlock {
     code: string;
     block: GraphQLClient.BlockInfo;
   }
 
-  export interface ResponseGetBlocks {
+  interface ResponseGetBlocks {
     code: string;
     page: GraphQLClient.PageInfo;
-    blocks: Array<GraphQLClient.BlockInfoSimple>;
+    blocks: GraphQLClient.BlockInfoSimple[];
   }
 
-  export interface ResponseGetChainInfo {
+  interface ResponseGetChainInfo {
     code: string;
     info: GraphQLClient.ChainInfo;
   }
 
-  export interface ResponseGetConfig {
+  interface ResponseGetConfig {
     code: string;
     config: string;
   }
 
-  export interface ResponseGetDelegateState {
+  interface ResponseGetDelegateState {
     code: string;
     state: GraphQLClient.DelegateState;
   }
 
-  export interface ResponseGetEvidenceState {
+  interface ResponseGetEvidenceState {
     code: string;
     state: GraphQLClient.EvidenceState;
   }
 
-  export interface ResponseGetFactoryState {
+  interface ResponseGetFactoryState {
     code: string;
     state: GraphQLClient.AssetFactoryState;
   }
 
-  export interface ResponseGetForgeState {
+  interface ResponseGetForgeState {
     code: string;
     state: GraphQLClient.ForgeState;
   }
 
-  export interface ResponseGetForgeStats {
+  interface ResponseGetForgeStats {
     code: string;
     forgeStats: GraphQLClient.ForgeStats;
   }
 
-  export interface ResponseGetNetInfo {
+  interface ResponseGetNetInfo {
     code: string;
     netInfo: GraphQLClient.NetInfo;
   }
 
-  export interface ResponseGetNodeInfo {
+  interface ResponseGetNodeInfo {
     code: string;
     info: GraphQLClient.NodeInfo;
   }
 
-  export interface ResponseGetRollupBlock {
+  interface ResponseGetRollupBlock {
     code: string;
     block: GraphQLClient.RollupBlock;
   }
 
-  export interface ResponseGetRollupState {
+  interface ResponseGetRollupState {
     code: string;
     state: GraphQLClient.RollupState;
   }
 
-  export interface ResponseGetStakeState {
+  interface ResponseGetStakeState {
     code: string;
     state: GraphQLClient.StakeState;
   }
 
-  export interface ResponseGetTokenState {
+  interface ResponseGetTokenState {
     code: string;
     state: GraphQLClient.TokenState;
   }
 
-  export interface ResponseGetTx {
+  interface ResponseGetTx {
     code: string;
     info: GraphQLClient.TransactionInfo;
   }
 
-  export interface ResponseGetUnconfirmedTxs {
+  interface ResponseGetUnconfirmedTxs {
     code: string;
     page: GraphQLClient.PageInfo;
     unconfirmedTxs: GraphQLClient.UnconfirmedTxs;
   }
 
-  export interface ResponseGetValidatorsInfo {
+  interface ResponseGetValidatorsInfo {
     code: string;
     validatorsInfo: GraphQLClient.ValidatorsInfo;
   }
 
-  export interface ResponseListAssetTransactions {
+  interface ResponseListAssetTransactions {
     code: string;
     page: GraphQLClient.PageInfo;
-    transactions: Array<GraphQLClient.IndexedTransaction>;
+    transactions: GraphQLClient.IndexedTransaction[];
   }
 
-  export interface ResponseListAssets {
+  interface ResponseListAssets {
     code: string;
     page: GraphQLClient.PageInfo;
-    assets: Array<GraphQLClient.IndexedAssetState>;
+    assets: GraphQLClient.IndexedAssetState[];
   }
 
-  export interface ResponseListBlocks {
+  interface ResponseListBlocks {
     code: string;
     page: GraphQLClient.PageInfo;
-    blocks: Array<GraphQLClient.IndexedBlock>;
+    blocks: GraphQLClient.IndexedBlock[];
   }
 
-  export interface ResponseListFactories {
+  interface ResponseListFactories {
     code: string;
     page: GraphQLClient.PageInfo;
-    factories: Array<GraphQLClient.IndexedFactoryState>;
+    factories: GraphQLClient.IndexedFactoryState[];
   }
 
-  export interface ResponseListRollupBlocks {
+  interface ResponseListRollupBlocks {
     code: string;
     page: GraphQLClient.PageInfo;
-    blocks: Array<GraphQLClient.IndexedRollupBlock>;
+    blocks: GraphQLClient.IndexedRollupBlock[];
   }
 
-  export interface ResponseListRollupValidators {
+  interface ResponseListRollupValidators {
     code: string;
     page: GraphQLClient.PageInfo;
-    validators: Array<GraphQLClient.IndexedRollupValidator>;
+    validators: GraphQLClient.IndexedRollupValidator[];
   }
 
-  export interface ResponseListRollups {
+  interface ResponseListRollups {
     code: string;
     page: GraphQLClient.PageInfo;
-    rollups: Array<GraphQLClient.IndexedRollupState>;
+    rollups: GraphQLClient.IndexedRollupState[];
   }
 
-  export interface ResponseListStakes {
+  interface ResponseListStakes {
     code: string;
     page: GraphQLClient.PageInfo;
-    stakes: Array<GraphQLClient.IndexedStakeState>;
+    stakes: GraphQLClient.IndexedStakeState[];
   }
 
-  export interface ResponseListTokens {
+  interface ResponseListTokens {
     code: string;
     page: GraphQLClient.PageInfo;
-    tokens: Array<GraphQLClient.IndexedTokenState>;
+    tokens: GraphQLClient.IndexedTokenState[];
   }
 
-  export interface ResponseListTopAccounts {
+  interface ResponseListTopAccounts {
     code: string;
     page: GraphQLClient.PageInfo;
-    accounts: Array<GraphQLClient.IndexedAccountState>;
+    accounts: GraphQLClient.IndexedAccountState[];
   }
 
-  export interface ResponseListTransactions {
+  interface ResponseListTransactions {
     code: string;
     page: GraphQLClient.PageInfo;
-    transactions: Array<GraphQLClient.IndexedTransaction>;
+    transactions: GraphQLClient.IndexedTransaction[];
   }
 
-  export interface ResponseSearch {
+  interface ResponseSearch {
     code: string;
     page: GraphQLClient.PageInfo;
-    results: Array<GraphQLClient.SearchResult>;
+    results: GraphQLClient.SearchResult[];
   }
 
-  export interface ResponseSendTx {
+  interface ResponseSendTx {
     code: string;
     hash: string;
   }
 
-  export interface ResumeRollupTx {
+  interface ResumeRollupTx {
     rollup: string;
     data: GraphQLClient.Any;
   }
 
-  export interface RevokeDelegateTx {
+  interface RevokeDelegateTx {
     address: string;
     to: string;
-    typeUrls: Array<string>;
+    typeUrls: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface RevokeStakeTx {
+  interface RevokeStakeTx {
     address: string;
-    outputs: Array<GraphQLClient.TransactionInput>;
+    outputs: GraphQLClient.TransactionInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface RollupBlock {
+  interface RollupBlock {
     hash: string;
     height: number;
     merkleRoot: string;
     previousHash: string;
     txsHash: string;
-    txs: Array<string>;
+    txs: string[];
     proposer: string;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     rollup: string;
     mintedAmount: string;
     burnedAmount: string;
@@ -1793,12 +1963,12 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface RollupState {
+  interface RollupState {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<GraphQLClient.RollupValidator>;
-    validators: Array<GraphQLClient.RollupValidator>;
+    seedValidators: GraphQLClient.RollupValidator[];
+    validators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -1830,55 +2000,55 @@ declare namespace GraphQLClient {
     leaveWaitingPeriod: number;
     publishWaitingPeriod: number;
     publishSlashRate: number;
-    migrateHistory: Array<string>;
+    migrateHistory: string[];
     context: GraphQLClient.StateContext;
     data: GraphQLClient.Any;
   }
 
-  export interface RollupValidator {
+  interface RollupValidator {
     pk: string;
     address: string;
     endpoint: string;
   }
 
-  export interface SearchResult {
+  interface SearchResult {
     type: string;
     id: string;
   }
 
-  export interface StakeState {
+  interface StakeState {
     address: string;
     sender: string;
     receiver: string;
-    tokens: Array<GraphQLClient.IndexedTokenInput>;
-    assets: Array<string>;
+    tokens: GraphQLClient.IndexedTokenInput[];
+    assets: string[];
     revocable: boolean;
     message: string;
     revokeWaitingPeriod: number;
-    revokedTokens: Array<GraphQLClient.IndexedTokenInput>;
-    revokedAssets: Array<string>;
+    revokedTokens: GraphQLClient.IndexedTokenInput[];
+    revokedAssets: string[];
     context: GraphQLClient.StateContext;
     data: GraphQLClient.Any;
   }
 
-  export interface StakeTx {
+  interface StakeTx {
     address: string;
     receiver: string;
-    inputs: Array<GraphQLClient.TransactionInput>;
+    inputs: GraphQLClient.TransactionInput[];
     locked: boolean;
     message: string;
     revokeWaitingPeriod: number;
     data: GraphQLClient.Any;
   }
 
-  export interface StateContext {
+  interface StateContext {
     genesisTx: GraphQLClient.TransactionInfo;
     renaissanceTx: GraphQLClient.TransactionInfo;
     genesisTime: string;
     renaissanceTime: string;
   }
 
-  export interface TokenInfo {
+  interface TokenInfo {
     address: string;
     balance: string;
     decimal: number;
@@ -1886,12 +2056,12 @@ declare namespace GraphQLClient {
     symbol: string;
   }
 
-  export interface TokenInput {
+  interface TokenInput {
     address: string;
     value: string;
   }
 
-  export interface TokenState {
+  interface TokenState {
     address: string;
     issuer: string;
     name: string;
@@ -1906,21 +2076,21 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface TokenSymbol {
+  interface TokenSymbol {
     address: string;
     symbol: string;
     decimal: number;
     unit: string;
   }
 
-  export interface Transaction {
+  interface Transaction {
     from: string;
     delegator: string;
     nonce: string;
     chainId: string;
     pk: string;
     signature: string;
-    signatures: Array<GraphQLClient.Multisig>;
+    signatures: GraphQLClient.Multisig[];
     itxJson: undefined;
     sender: string;
     receiver: string;
@@ -1929,67 +2099,67 @@ declare namespace GraphQLClient {
     gasPaid: string;
   }
 
-  export interface TransactionConfig {
+  interface TransactionConfig {
     maxAssetSize: number;
     maxListSize: number;
     maxMultisig: number;
     delegate: GraphQLClient.DelegateConfig;
-    txFee: Array<GraphQLClient.TxFeeConfig>;
+    txFee: GraphQLClient.TxFeeConfig[];
     txGas: GraphQLClient.TxGasConfig;
   }
 
-  export interface TransactionInfo {
+  interface TransactionInfo {
     tx: GraphQLClient.Transaction;
     height: string;
     index: number;
     hash: string;
-    tags: Array<GraphQLClient.KVPair>;
+    tags: GraphQLClient.KVPair[];
     code: string;
     time: string;
-    receipts: Array<GraphQLClient.TransactionReceipt>;
+    receipts: GraphQLClient.TransactionReceipt[];
     sender: string;
     receiver: string;
-    tokenSymbols: Array<GraphQLClient.TokenSymbol>;
+    tokenSymbols: GraphQLClient.TokenSymbol[];
   }
 
-  export interface TransactionInput {
+  interface TransactionInput {
     owner: string;
-    tokens: Array<GraphQLClient.TokenInput>;
-    assets: Array<string>;
+    tokens: GraphQLClient.TokenInput[];
+    assets: string[];
   }
 
-  export interface TransactionReceipt {
+  interface TransactionReceipt {
     address: string;
-    changes: Array<GraphQLClient.ReceiptChange>;
+    changes: GraphQLClient.ReceiptChange[];
   }
 
-  export interface TransferTx {
+  interface TransferTx {
     to: string;
     value: string;
-    assets: Array<string>;
+    assets: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface TransferV2Tx {
+  interface TransferV2Tx {
     to: string;
     value: string;
-    assets: Array<string>;
-    tokens: Array<GraphQLClient.TokenInput>;
+    assets: string[];
+    tokens: GraphQLClient.TokenInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface TransferV3Tx {
-    inputs: Array<GraphQLClient.TransactionInput>;
-    outputs: Array<GraphQLClient.TransactionInput>;
+  interface TransferV3Tx {
+    inputs: GraphQLClient.TransactionInput[];
+    outputs: GraphQLClient.TransactionInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface TxFeeConfig {
+  interface TxFeeConfig {
     typeUrl: string;
     fee: string;
   }
 
-  export interface TxGasConfig {
+  interface TxGasConfig {
     price: number;
     createState: number;
     updateState: number;
@@ -1999,18 +2169,18 @@ declare namespace GraphQLClient {
     stakeLockPeriod: number;
   }
 
-  export interface UnconfirmedTxs {
+  interface UnconfirmedTxs {
     nTxs: number;
-    txs: Array<GraphQLClient.Transaction>;
+    txs: GraphQLClient.Transaction[];
   }
 
-  export interface UpdateAssetTx {
+  interface UpdateAssetTx {
     address: string;
     moniker: string;
     data: GraphQLClient.Any;
   }
 
-  export interface UpdateRollupTx {
+  interface UpdateRollupTx {
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -2038,33 +2208,33 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface UpgradeInfo {
+  interface UpgradeInfo {
     height: string;
     version: string;
   }
 
-  export interface UpgradeNodeTx {
+  interface UpgradeNodeTx {
     height: number;
     version: string;
     override: boolean;
   }
 
-  export interface UpgradeTask {
+  interface UpgradeTask {
     type: GraphQLClient.UpgradeType;
     dataHash: string;
-    actions: Array<GraphQLClient.UpgradeAction>;
+    actions: GraphQLClient.UpgradeAction[];
   }
 
-  export interface UpgradeTasks {
-    item: Array<GraphQLClient.UpgradeTask>;
+  interface UpgradeTasks {
+    item: GraphQLClient.UpgradeTask[];
   }
 
-  export interface Validator {
+  interface Validator {
     address: string;
     power: string;
   }
 
-  export interface ValidatorInfo {
+  interface ValidatorInfo {
     address: string;
     pubKey: GraphQLClient.PubKey;
     votingPower: string;
@@ -2073,31 +2243,31 @@ declare namespace GraphQLClient {
     geoInfo: GraphQLClient.GeoInfo;
   }
 
-  export interface ValidatorsInfo {
+  interface ValidatorsInfo {
     blockHeight: string;
-    validators: Array<GraphQLClient.ValidatorInfo>;
+    validators: GraphQLClient.ValidatorInfo[];
   }
 
-  export interface VariableInput {
+  interface VariableInput {
     name: string;
     value: string;
     description: string;
     required: boolean;
   }
 
-  export interface Version {
+  interface Version {
     block: number;
     app: number;
   }
 
-  export interface WalletType {
+  interface WalletType {
     pk: GraphQLClient.KeyType;
     hash: GraphQLClient.HashType;
     address: GraphQLClient.EncodingType;
     role: GraphQLClient.RoleType;
   }
 
-  export interface WithdrawTokenV2Tx {
+  interface WithdrawTokenV2Tx {
     token: GraphQLClient.TokenInput;
     to: string;
     rollup: string;
@@ -2107,171 +2277,176 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface GetAccountStateParams {
+  interface GetAccountStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface GetAssetStateParams {
+  interface GetAssetStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface GetFactoryStateParams {
+  interface GetFactoryStateParams {
     address: string;
   }
 
-  export interface GetDelegateStateParams {
+  interface GetDelegateStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface GetTokenStateParams {
+  interface GetTokenStateParams {
     address: string;
   }
 
-  export interface GetEvidenceStateParams {
+  interface GetEvidenceStateParams {
     hash: string;
   }
 
-  export interface GetForgeStateParams {
+  interface GetForgeStateParams {
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface GetTxParams {
+  interface GetTxParams {
     hash: string;
   }
 
-  export interface GetBlockParams {
+  interface GetBlockParams {
     height: string;
   }
 
-  export interface GetBlocksParams {
+  interface GetBlocksParams {
     emptyExcluded: boolean;
-    heightFilter: undefined;
-    paging: undefined;
+    heightFilter: GraphQLClient.RangeFilterInput;
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface GetUnconfirmedTxsParams {
-    paging: undefined;
+  interface GetUnconfirmedTxsParams {
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface GetConfigParams {
+  interface GetConfigParams {
     parsed: boolean;
   }
 
-  export interface ListAssetTransactionsParams {
+  interface ListAssetTransactionsParams {
     address: string;
-    paging: undefined;
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface ListAssetsParams {
+  interface ListAssetsParams {
     ownerAddress: string;
-    paging: undefined;
+    paging: GraphQLClient.PageInput;
     factoryAddress: string;
-    timeFilter: undefined;
+    timeFilter: GraphQLClient.TimeFilterInput;
   }
 
-  export interface ListBlocksParams {
-    heightFilter: undefined;
-    numInvalidTxsFilter: undefined;
-    numTxsFilter: undefined;
-    paging: undefined;
+  interface ListBlocksParams {
+    heightFilter: GraphQLClient.RangeFilterInput;
+    numInvalidTxsFilter: GraphQLClient.RangeFilterInput;
+    numTxsFilter: GraphQLClient.RangeFilterInput;
+    paging: GraphQLClient.PageInput;
     proposer: string;
-    timeFilter: undefined;
+    timeFilter: GraphQLClient.TimeFilterInput;
   }
 
-  export interface ListTopAccountsParams {
-    paging: undefined;
+  interface ListTopAccountsParams {
+    paging: GraphQLClient.PageInput;
     tokenAddress: string;
   }
 
-  export interface ListTransactionsParams {
-    addressFilter: undefined;
-    paging: undefined;
-    timeFilter: undefined;
-    typeFilter: undefined;
-    validityFilter: undefined;
-    factoryFilter: undefined;
-    tokenFilter: undefined;
-    assetFilter: undefined;
-    accountFilter: undefined;
-    txFilter: undefined;
-    rollupFilter: undefined;
+  interface ListTransactionsParams {
+    addressFilter: GraphQLClient.AddressFilterInput;
+    paging: GraphQLClient.PageInput;
+    timeFilter: GraphQLClient.TimeFilterInput;
+    typeFilter: GraphQLClient.TypeFilterInput;
+    validityFilter: GraphQLClient.ValidityFilterInput;
+    factoryFilter: GraphQLClient.FactoryFilterInput;
+    tokenFilter: GraphQLClient.TokenFilterInput;
+    assetFilter: GraphQLClient.AssetFilterInput;
+    accountFilter: GraphQLClient.AccountFilterInput;
+    txFilter: GraphQLClient.TxFilterInput;
+    rollupFilter: GraphQLClient.RollupFilterInput;
   }
 
-  export interface ListTokensParams {
+  interface ListTokensParams {
     issuerAddress: string;
-    paging: undefined;
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface ListFactoriesParams {
+  interface ListFactoriesParams {
     ownerAddress: string;
-    addressList: Array<string>;
-    paging: undefined;
+    addressList: string[];
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface GetAccountTokensParams {
+  interface GetAccountTokensParams {
     address: string;
     token: string;
   }
 
-  export interface GetStakeStateParams {
+  interface GetStakeStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface ListStakesParams {
-    addressFilter: undefined;
-    assetFilter: undefined;
-    timeFilter: undefined;
-    paging: undefined;
+  interface ListStakesParams {
+    addressFilter: GraphQLClient.AddressFilterInput;
+    assetFilter: GraphQLClient.AssetFilterInput;
+    timeFilter: GraphQLClient.TimeFilterInput;
+    paging: GraphQLClient.PageInput;
   }
 
-  export interface GetRollupStateParams {
+  interface GetRollupStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface ListRollupsParams {
-    paging: undefined;
+  interface ListRollupsParams {
+    paging: GraphQLClient.PageInput;
     tokenAddress: string;
     erc20TokenAddress: string;
     foreignTokenAddress: string;
   }
 
-  export interface GetRollupBlockParams {
+  interface GetRollupBlockParams {
     hash: string;
     height: string;
     rollupAddress: string;
   }
 
-  export interface ListRollupBlocksParams {
-    paging: undefined;
+  interface ListRollupBlocksParams {
+    paging: GraphQLClient.PageInput;
     rollupAddress: string;
     tokenAddress: string;
     proposer: string;
-    validatorFilter: undefined;
-    txFilter: undefined;
+    validatorFilter: GraphQLClient.ValidatorFilterInput;
+    txFilter: GraphQLClient.TxFilterInput;
   }
 
-  export interface ListRollupValidatorsParams {
-    paging: undefined;
+  interface ListRollupValidatorsParams {
+    paging: GraphQLClient.PageInput;
     rollupAddress: string;
   }
 
-  export interface SearchParams {
-    paging: undefined;
+  interface SearchParams {
+    paging: GraphQLClient.PageInput;
     keyword: string;
   }
 
-  export interface SendTxParams {
+  interface EstimateGasParams {
+    typeUrl: string;
+    tx: string;
+  }
+
+  interface SendTxParams {
     commit: boolean;
     token: string;
     tx: string;