@ocap/sdk 1.18.8 → 1.18.9

package/index.d.ts

@@ -241,9 +241,9 @@ export declare function formatTxType(type: string): any;
 /// <reference types="node" />
 import { EncodingType, BytesType } from '@ocap/util';
 import { DidType, DIDType, DIDTypeStr, DIDTypeArg } from '@arcblock/did';
-declare type KeyPairType = {
-  sk?: BytesType;
-  pk?: BytesType;
+declare type KeyPairType<T extends BytesType = string> = {
+  sk?: T;
+  pk?: T;
   address?: string;
 };
 export declare type SerializedWallet = {
@@ -252,26 +252,26 @@ export declare type SerializedWallet = {
   sk: string;
   address: string;
 };
-export interface WalletObject {
+export interface WalletObject<T extends BytesType = string> {
   type: DIDType;
-  secretKey: BytesType;
-  publicKey: BytesType;
+  secretKey: T;
+  publicKey: T;
   address: string;
-  hash(data: BytesType, round?: number, encoding?: 'hex'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base16'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base58'): string;
-  hash(data: BytesType, round?: number, encoding?: 'base64'): string;
-  hash(data: BytesType, round?: number, encoding?: 'buffer'): Buffer;
-  hash(data: BytesType, round?: number, encoding?: 'Uint8Array'): Uint8Array;
-  hash(data: BytesType, round?: number, encoding?: EncodingType): BytesType;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'hex'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base16'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base58'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'base64'): string;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
-  sign(data: BytesType, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
-  verify(data: BytesType, signature: BytesType, hashBeforeVerify?: boolean): boolean;
+  hash(data: T, round?: number, encoding?: 'hex'): string;
+  hash(data: T, round?: number, encoding?: 'base16'): string;
+  hash(data: T, round?: number, encoding?: 'base58'): string;
+  hash(data: T, round?: number, encoding?: 'base64'): string;
+  hash(data: T, round?: number, encoding?: 'buffer'): Buffer;
+  hash(data: T, round?: number, encoding?: 'Uint8Array'): Uint8Array;
+  hash(data: T, round?: number, encoding?: EncodingType): BytesType;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'hex'): string;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'base16'): string;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'base58'): string;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'base64'): string;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'buffer'): Buffer;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: 'Uint8Array'): Uint8Array;
+  sign(data: T, hashBeforeSign?: boolean, encoding?: EncodingType): BytesType;
+  verify(data: T, signature: T, hashBeforeVerify?: boolean): boolean;
   ethHash(data: string): string;
   ethSign(data: string, hashBeforeSign?: boolean): string;
   ethVerify(data: string, signature: string, hashBeforeVerify?: boolean): boolean;
@@ -285,7 +285,7 @@ export declare const WalletType: typeof DidType;
 /**
  * Generate an wallet instance that can be used to sign a message or verify a signature
  */
-export declare function Wallet(keyPair: KeyPairType, t?: DIDTypeArg): WalletObject;
+export declare function Wallet<T extends BytesType = string>(keyPair: KeyPairType<T>, t?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from secretKey
  *
@@ -304,25 +304,25 @@ export declare function Wallet(keyPair: KeyPairType, t?: DIDTypeArg): WalletObje
  * assert.equal(signature, sig, "signature should match");
  * assert.ok(wallet.verify(message, signature), "signature should be verified");
  */
-export declare function fromSecretKey(sk: BytesType, _type?: DIDTypeArg): WalletObject;
+export declare function fromSecretKey<T extends BytesType = string>(sk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from publicKey
  */
-export declare function fromPublicKey(pk: BytesType, _type?: DIDTypeArg): WalletObject;
+export declare function fromPublicKey<T extends BytesType = string>(pk: T, _type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generate a wallet from address (did)
  *
  * Since we do not know the publicKey and secretKey, this kind of wallet cannot be used for signing and verifying
  */
-export declare function fromAddress(address: string): WalletObject;
+export declare function fromAddress<T extends BytesType = string>(address: string): WalletObject<T>;
 /**
  * Generate a wallet by generating a random secretKey
  */
-export declare function fromRandom(_type?: DIDTypeArg): WalletObject;
+export declare function fromRandom<T extends BytesType = string>(_type?: DIDTypeArg): WalletObject<T>;
 /**
  * Generating a wallet from a serialized json presentation of another wallet
  */
-export declare function fromJSON(json: SerializedWallet): WalletObject;
+export declare function fromJSON<T extends BytesType = string>(json: SerializedWallet): WalletObject<T>;
 /**
  * Check if an object is valid wallet object
  */
@@ -361,9 +361,12 @@ export declare function toStakeAddress(sender: string, receiver: string): string
  * Generate an delegate address, eg: the did of the delegation
  */
 export declare function toDelegateAddress(delegator: string, delegatee: string): string;
-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];
+};
+
 /*~ This declaration specifies that the class constructor function
  *~ is the exported object from the file
  */
@@ -852,22 +855,22 @@ declare interface OcapSDK {
 }
 
 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;
@@ -883,30 +886,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,
@@ -916,13 +919,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,
@@ -947,7 +950,7 @@ declare namespace GraphQLClient {
     ROLE_ANY,
   }
 
-  export enum StatusCode {
+  enum StatusCode {
     OK,
     INVALID_NONCE,
     INVALID_SIGNATURE,
@@ -1025,7 +1028,7 @@ declare namespace GraphQLClient {
     TIMEOUT,
   }
 
-  export enum UpgradeAction {
+  enum UpgradeAction {
     VERIFY,
     BACKUP,
     REPLACE,
@@ -1040,7 +1043,7 @@ declare namespace GraphQLClient {
     DROP_ADDRESS_BOOK,
   }
 
-  export enum UpgradeType {
+  enum UpgradeType {
     CONFIG_APP,
     CONFIG_FORGE,
     CONFIG_DFS,
@@ -1053,100 +1056,100 @@ declare namespace GraphQLClient {
     EXE_P2P,
   }
 
-  export enum Validity {
+  enum Validity {
     BOTH,
     VALID,
     INVALID,
   }
 
-  export interface AccountFilterInput {}
+  interface AccountFilterInput {}
 
-  export interface AddressFilterInput {}
+  interface AddressFilterInput {}
 
-  export interface AssetFilterInput {}
+  interface AssetFilterInput {}
 
-  export interface FactoryFilterInput {}
+  interface FactoryFilterInput {}
 
-  export interface PageInput {}
+  interface PageInput {}
 
-  export interface PageOrderInput {}
+  interface PageOrderInput {}
 
-  export interface RangeFilterInput {}
+  interface RangeFilterInput {}
 
-  export interface RequestGetAccountTokensInput {}
+  interface RequestGetAccountTokensInput {}
 
-  export interface RequestGetBlockInput {}
+  interface RequestGetBlockInput {}
 
-  export interface RequestGetBlocksInput {}
+  interface RequestGetBlocksInput {}
 
-  export interface RequestGetConfigInput {}
+  interface RequestGetConfigInput {}
 
-  export interface RequestGetEvidenceStateInput {}
+  interface RequestGetEvidenceStateInput {}
 
-  export interface RequestGetRollupBlockInput {}
+  interface RequestGetRollupBlockInput {}
 
-  export interface RequestGetStateInput {}
+  interface RequestGetStateInput {}
 
-  export interface RequestGetTxInput {}
+  interface RequestGetTxInput {}
 
-  export interface RequestListAssetTransactionsInput {}
+  interface RequestListAssetTransactionsInput {}
 
-  export interface RequestListAssetsInput {}
+  interface RequestListAssetsInput {}
 
-  export interface RequestListBlocksInput {}
+  interface RequestListBlocksInput {}
 
-  export interface RequestListFactoriesInput {}
+  interface RequestListFactoriesInput {}
 
-  export interface RequestListRollupBlocksInput {}
+  interface RequestListRollupBlocksInput {}
 
-  export interface RequestListRollupValidatorsInput {}
+  interface RequestListRollupValidatorsInput {}
 
-  export interface RequestListRollupsInput {}
+  interface RequestListRollupsInput {}
 
-  export interface RequestListStakesInput {}
+  interface RequestListStakesInput {}
 
-  export interface RequestListTokensInput {}
+  interface RequestListTokensInput {}
 
-  export interface RequestListTopAccountsInput {}
+  interface RequestListTopAccountsInput {}
 
-  export interface RequestListTransactionsInput {}
+  interface RequestListTransactionsInput {}
 
-  export interface RequestSearchInput {}
+  interface RequestSearchInput {}
 
-  export interface RequestSendTxInput {}
+  interface RequestSendTxInput {}
 
-  export interface RollupFilterInput {}
+  interface RollupFilterInput {}
 
-  export interface TimeFilterInput {}
+  interface TimeFilterInput {}
 
-  export interface TokenFilterInput {}
+  interface TokenFilterInput {}
 
-  export interface TxFilterInput {}
+  interface TxFilterInput {}
 
-  export interface TypeFilterInput {}
+  interface TypeFilterInput {}
 
-  export interface ValidatorFilterInput {}
+  interface ValidatorFilterInput {}
 
-  export interface ValidityFilterInput {}
+  interface ValidityFilterInput {}
 
-  export interface WalletInfoInput {}
+  interface WalletInfoInput {}
 
-  export interface WalletTypeInput {}
+  interface WalletTypeInput {}
 
-  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;
@@ -1157,78 +1160,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;
@@ -1240,27 +1243,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;
@@ -1272,15 +1275,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;
@@ -1292,7 +1295,7 @@ declare namespace GraphQLClient {
     lastBlockId: GraphQLClient.BlockID;
   }
 
-  export interface ChainInfo {
+  interface ChainInfo {
     id: string;
     network: string;
     moniker: string;
@@ -1306,16 +1309,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;
@@ -1324,24 +1327,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;
@@ -1352,42 +1355,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;
@@ -1417,7 +1420,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface CreateTokenTx {
+  interface CreateTokenTx {
     name: string;
     description: string;
     symbol: string;
@@ -1431,23 +1434,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;
@@ -1455,26 +1458,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;
@@ -1484,28 +1487,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;
@@ -1513,7 +1516,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ExchangeV2Tx {
+  interface ExchangeV2Tx {
     to: string;
     sender: GraphQLClient.ExchangeInfoV2;
     receiver: GraphQLClient.ExchangeInfoV2;
@@ -1521,7 +1524,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ForeignToken {
+  interface ForeignToken {
     type: string;
     contractAddress: string;
     chainType: string;
@@ -1529,46 +1532,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;
@@ -1581,14 +1584,14 @@ declare namespace GraphQLClient {
     address: string;
   }
 
-  export interface GeoInfo {
+  interface GeoInfo {
     city: string;
     country: string;
     latitude: number;
     longitude: number;
   }
 
-  export interface IndexedAccountState {
+  interface IndexedAccountState {
     address: string;
     balance: string;
     numAssets: string;
@@ -1602,11 +1605,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;
@@ -1620,11 +1623,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;
@@ -1632,27 +1635,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;
@@ -1660,15 +1663,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;
@@ -1679,12 +1682,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;
@@ -1718,11 +1721,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;
@@ -1742,23 +1745,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;
@@ -1766,7 +1769,7 @@ declare namespace GraphQLClient {
     symbol: string;
   }
 
-  export interface IndexedTokenState {
+  interface IndexedTokenState {
     name: string;
     description: string;
     symbol: string;
@@ -1782,7 +1785,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedTransaction {
+  interface IndexedTransaction {
     hash: string;
     sender: string;
     receiver: string;
@@ -1791,37 +1794,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;
@@ -1829,16 +1832,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;
@@ -1846,30 +1849,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;
@@ -1883,35 +1886,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;
@@ -1920,227 +1923,227 @@ 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 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;
   }
 
-  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;
@@ -2150,12 +2153,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;
@@ -2187,55 +2190,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;
@@ -2243,12 +2246,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;
@@ -2263,21 +2266,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;
@@ -2286,67 +2289,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;
@@ -2356,18 +2359,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;
@@ -2395,33 +2398,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;
@@ -2430,31 +2433,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;
@@ -2464,76 +2467,76 @@ 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;
   }
 
-  export interface GetUnconfirmedTxsParams {
+  interface GetUnconfirmedTxsParams {
     paging: undefined;
   }
 
-  export interface GetConfigParams {
+  interface GetConfigParams {
     parsed: boolean;
   }
 
-  export interface ListAssetTransactionsParams {
+  interface ListAssetTransactionsParams {
     address: string;
     paging: undefined;
   }
 
-  export interface ListAssetsParams {
+  interface ListAssetsParams {
     ownerAddress: string;
     paging: undefined;
     factoryAddress: string;
     timeFilter: undefined;
   }
 
-  export interface ListBlocksParams {
+  interface ListBlocksParams {
     heightFilter: undefined;
     numInvalidTxsFilter: undefined;
     numTxsFilter: undefined;
@@ -2542,12 +2545,12 @@ declare namespace GraphQLClient {
     timeFilter: undefined;
   }
 
-  export interface ListTopAccountsParams {
+  interface ListTopAccountsParams {
     paging: undefined;
     tokenAddress: string;
   }
 
-  export interface ListTransactionsParams {
+  interface ListTransactionsParams {
     addressFilter: undefined;
     paging: undefined;
     timeFilter: undefined;
@@ -2561,55 +2564,55 @@ declare namespace GraphQLClient {
     rollupFilter: undefined;
   }
 
-  export interface ListTokensParams {
+  interface ListTokensParams {
     issuerAddress: string;
     paging: undefined;
   }
 
-  export interface ListFactoriesParams {
+  interface ListFactoriesParams {
     ownerAddress: string;
-    addressList: Array<string>;
+    addressList: string[];
     paging: undefined;
   }
 
-  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 {
+  interface ListStakesParams {
     addressFilter: undefined;
     assetFilter: undefined;
     timeFilter: undefined;
     paging: undefined;
   }
 
-  export interface GetRollupStateParams {
+  interface GetRollupStateParams {
     address: string;
     height: string;
-    keys: Array<string>;
+    keys: string[];
   }
 
-  export interface ListRollupsParams {
+  interface ListRollupsParams {
     paging: undefined;
     tokenAddress: string;
     erc20TokenAddress: string;
     foreignTokenAddress: string;
   }
 
-  export interface GetRollupBlockParams {
+  interface GetRollupBlockParams {
     hash: string;
     height: string;
     rollupAddress: string;
   }
 
-  export interface ListRollupBlocksParams {
+  interface ListRollupBlocksParams {
     paging: undefined;
     rollupAddress: string;
     tokenAddress: string;
@@ -2618,17 +2621,17 @@ declare namespace GraphQLClient {
     txFilter: undefined;
   }
 
-  export interface ListRollupValidatorsParams {
+  interface ListRollupValidatorsParams {
     paging: undefined;
     rollupAddress: string;
   }
 
-  export interface SearchParams {
+  interface SearchParams {
     paging: undefined;
     keyword: string;
   }
 
-  export interface SendTxParams {
+  interface SendTxParams {
     commit: boolean;
     token: string;
     tx: string;