@ocap/sdk 1.18.7 → 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,6 +361,11 @@ 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 { 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
@@ -394,225 +399,389 @@ declare interface OcapSDK {
   getTxMultiSignMethods(): Array<string>;
   getType(x: string): Object;
   decodeTx(input: string | buffer): object;
-  declare(params: object, extra: any): Promise<string>;
-  migrateAccount(params: object, extra: any): Promise<string>;
-  delegate(params: object, extra: any): Promise<string>;
-  revokeDelegate(params: object, extra: any): Promise<string>;
-  createAsset(params: object, extra: any): Promise<string>;
-  updateAsset(params: object, extra: any): Promise<string>;
-  consumeAsset(params: object, extra: any): Promise<string>;
-  createAssetFactory(params: object, extra: any): Promise<string>;
-  acquireAsset(params: object, extra: any): Promise<string>;
-  upgradeNode(params: object, extra: any): Promise<string>;
-  transfer(params: object, extra: any): Promise<string>;
-  prepareExchange(params: object, extra: any): Promise<string>;
-  finalizeExchange(params: object, extra: any): Promise<string>;
-  exchange(params: object, extra: any): Promise<string>;
+  declare(params: object, extra?: any): Promise<string>;
+  migrateAccount(params: object, extra?: any): Promise<string>;
+  delegate(params: object, extra?: any): Promise<string>;
+  revokeDelegate(params: object, extra?: any): Promise<string>;
+  createAsset(params: object, extra?: any): Promise<string>;
+  updateAsset(params: object, extra?: any): Promise<string>;
+  consumeAsset(params: object, extra?: any): Promise<string>;
+  createAssetFactory(params: object, extra?: any): Promise<string>;
+  acquireAsset(params: object, extra?: any): Promise<string>;
+  upgradeNode(params: object, extra?: any): Promise<string>;
+  transfer(params: object, extra?: any): Promise<string>;
+  prepareExchange(params: object, extra?: any): Promise<string>;
+  finalizeExchange(params: object, extra?: any): Promise<string>;
+  exchange(params: object, extra?: any): Promise<string>;
 
   generateQueryFns(): void;
   generateSubscriptionFns(): void;
   generateMutationFns(): void;
 
   sendAccountMigrateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.AccountMigrateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AccountMigrateTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   sendAcquireAssetV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV2Tx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   sendAcquireAssetV3Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV3Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV3Tx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   sendClaimBlockRewardTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ClaimBlockRewardTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimBlockRewardTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendClaimStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimStakeTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendCreateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateAssetTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
-  sendClaimStakeTx(param: GraphQLClient.TxParam<GraphQLClient.ClaimStakeTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendCreateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.CreateAssetTx>): Promise<GraphQLClient.ResponseSendTx>;
   sendCreateFactoryTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateFactoryTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateFactoryTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   sendCreateRollupBlockTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateRollupBlockTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupBlockTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendCreateRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendCreateTokenTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateTokenTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendDeclareTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DeclareTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendDelegateTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DelegateTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
-  sendCreateRollupTx(param: GraphQLClient.TxParam<GraphQLClient.CreateRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendCreateTokenTx(param: GraphQLClient.TxParam<GraphQLClient.CreateTokenTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendDeclareTx(param: GraphQLClient.TxParam<GraphQLClient.DeclareTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendDelegateTx(param: GraphQLClient.TxParam<GraphQLClient.DelegateTx>): Promise<GraphQLClient.ResponseSendTx>;
   sendDepositTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.DepositTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DepositTokenV2Tx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendExchangeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendExchangeV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeV2Tx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendJoinRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.JoinRollupTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendLeaveRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.LeaveRollupTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
-  sendExchangeTx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendExchangeV2Tx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeV2Tx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendJoinRollupTx(param: GraphQLClient.TxParam<GraphQLClient.JoinRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendLeaveRollupTx(param: GraphQLClient.TxParam<GraphQLClient.LeaveRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
   sendMigrateRollupContractTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupContractTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupContractTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   sendMigrateRollupTokenTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupTokenTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupTokenTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendMintAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MintAssetTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendPauseRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.PauseRollupTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendResumeRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ResumeRollupTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
-  sendMintAssetTx(param: GraphQLClient.TxParam<GraphQLClient.MintAssetTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendPauseRollupTx(param: GraphQLClient.TxParam<GraphQLClient.PauseRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendResumeRollupTx(param: GraphQLClient.TxParam<GraphQLClient.ResumeRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
   sendRevokeDelegateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.RevokeDelegateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeDelegateTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendRevokeStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeStakeTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.StakeTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendTransferTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendTransferV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV2Tx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendTransferV3Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV3Tx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendUpdateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateAssetTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendUpdateRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateRollupTx>>,
+    extra?: any
+  ): Promise<GraphQLClient.ResponseSendTx>;
+  sendUpgradeNodeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpgradeNodeTx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
-  sendRevokeStakeTx(param: GraphQLClient.TxParam<GraphQLClient.RevokeStakeTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendStakeTx(param: GraphQLClient.TxParam<GraphQLClient.StakeTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendTransferTx(param: GraphQLClient.TxParam<GraphQLClient.TransferTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendTransferV2Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV2Tx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendTransferV3Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV3Tx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendUpdateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.UpdateAssetTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendUpdateRollupTx(param: GraphQLClient.TxParam<GraphQLClient.UpdateRollupTx>): Promise<GraphQLClient.ResponseSendTx>;
-  sendUpgradeNodeTx(param: GraphQLClient.TxParam<GraphQLClient.UpgradeNodeTx>): Promise<GraphQLClient.ResponseSendTx>;
   sendWithdrawTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.WithdrawTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.WithdrawTokenV2Tx>>,
+    extra?: any
   ): Promise<GraphQLClient.ResponseSendTx>;
   encodeAccountMigrateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.AccountMigrateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AccountMigrateTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeAcquireAssetV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV2Tx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeAcquireAssetV3Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV3Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV3Tx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeClaimBlockRewardTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ClaimBlockRewardTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimBlockRewardTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeClaimStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimStakeTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeCreateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateAssetTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeClaimStakeTx(param: GraphQLClient.TxParam<GraphQLClient.ClaimStakeTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeCreateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.CreateAssetTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeCreateFactoryTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateFactoryTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateFactoryTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeCreateRollupBlockTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateRollupBlockTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupBlockTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeCreateRollupTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateRollupTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeCreateTokenTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateTokenTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeDeclareTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DeclareTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeDelegateTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DelegateTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeCreateTokenTx(param: GraphQLClient.TxParam<GraphQLClient.CreateTokenTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeDeclareTx(param: GraphQLClient.TxParam<GraphQLClient.DeclareTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeDelegateTx(param: GraphQLClient.TxParam<GraphQLClient.DelegateTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeDepositTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.DepositTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DepositTokenV2Tx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeExchangeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeExchangeV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeV2Tx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeJoinRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.JoinRollupTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeLeaveRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.LeaveRollupTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeExchangeTx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeExchangeV2Tx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeV2Tx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeJoinRollupTx(param: GraphQLClient.TxParam<GraphQLClient.JoinRollupTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeLeaveRollupTx(param: GraphQLClient.TxParam<GraphQLClient.LeaveRollupTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeMigrateRollupContractTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupContractTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupContractTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeMigrateRollupTokenTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupTokenTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupTokenTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeMintAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MintAssetTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodePauseRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.PauseRollupTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeMintAssetTx(param: GraphQLClient.TxParam<GraphQLClient.MintAssetTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodePauseRollupTx(param: GraphQLClient.TxParam<GraphQLClient.PauseRollupTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeResumeRollupTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ResumeRollupTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ResumeRollupTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   encodeRevokeDelegateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.RevokeDelegateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeDelegateTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeRevokeStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeStakeTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.StakeTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeTransferTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeTransferV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV2Tx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeTransferV3Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV3Tx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeUpdateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateAssetTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeRevokeStakeTx(param: GraphQLClient.TxParam<GraphQLClient.RevokeStakeTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeStakeTx(param: GraphQLClient.TxParam<GraphQLClient.StakeTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeTransferTx(param: GraphQLClient.TxParam<GraphQLClient.TransferTx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeTransferV2Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV2Tx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeTransferV3Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV3Tx>): Promise<GraphQLClient.EncodeTxResult>;
-  encodeUpdateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.UpdateAssetTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeUpdateRollupTx(
-    param: GraphQLClient.TxParam<GraphQLClient.UpdateRollupTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateRollupTx>>
+  ): Promise<GraphQLClient.EncodeTxResult>;
+  encodeUpgradeNodeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpgradeNodeTx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
-  encodeUpgradeNodeTx(param: GraphQLClient.TxParam<GraphQLClient.UpgradeNodeTx>): Promise<GraphQLClient.EncodeTxResult>;
   encodeWithdrawTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.WithdrawTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.WithdrawTokenV2Tx>>
   ): Promise<GraphQLClient.EncodeTxResult>;
   signAccountMigrateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.AccountMigrateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AccountMigrateTx>>
   ): Promise<GraphQLClient.Transaction>;
   signAcquireAssetV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV2Tx>>
   ): Promise<GraphQLClient.Transaction>;
   signAcquireAssetV3Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV3Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV3Tx>>
   ): Promise<GraphQLClient.Transaction>;
   signClaimBlockRewardTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ClaimBlockRewardTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimBlockRewardTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signClaimStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimStakeTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signCreateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateAssetTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signCreateFactoryTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateFactoryTx>>
   ): Promise<GraphQLClient.Transaction>;
-  signClaimStakeTx(param: GraphQLClient.TxParam<GraphQLClient.ClaimStakeTx>): Promise<GraphQLClient.Transaction>;
-  signCreateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.CreateAssetTx>): Promise<GraphQLClient.Transaction>;
-  signCreateFactoryTx(param: GraphQLClient.TxParam<GraphQLClient.CreateFactoryTx>): Promise<GraphQLClient.Transaction>;
   signCreateRollupBlockTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateRollupBlockTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupBlockTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signCreateRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signCreateTokenTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateTokenTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signDeclareTx(param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DeclareTx>>): Promise<GraphQLClient.Transaction>;
+  signDelegateTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DelegateTx>>
   ): Promise<GraphQLClient.Transaction>;
-  signCreateRollupTx(param: GraphQLClient.TxParam<GraphQLClient.CreateRollupTx>): Promise<GraphQLClient.Transaction>;
-  signCreateTokenTx(param: GraphQLClient.TxParam<GraphQLClient.CreateTokenTx>): Promise<GraphQLClient.Transaction>;
-  signDeclareTx(param: GraphQLClient.TxParam<GraphQLClient.DeclareTx>): Promise<GraphQLClient.Transaction>;
-  signDelegateTx(param: GraphQLClient.TxParam<GraphQLClient.DelegateTx>): Promise<GraphQLClient.Transaction>;
   signDepositTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.DepositTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DepositTokenV2Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signExchangeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signExchangeV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeV2Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signJoinRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.JoinRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signLeaveRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.LeaveRollupTx>>
   ): Promise<GraphQLClient.Transaction>;
-  signExchangeTx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeTx>): Promise<GraphQLClient.Transaction>;
-  signExchangeV2Tx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeV2Tx>): Promise<GraphQLClient.Transaction>;
-  signJoinRollupTx(param: GraphQLClient.TxParam<GraphQLClient.JoinRollupTx>): Promise<GraphQLClient.Transaction>;
-  signLeaveRollupTx(param: GraphQLClient.TxParam<GraphQLClient.LeaveRollupTx>): Promise<GraphQLClient.Transaction>;
   signMigrateRollupContractTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupContractTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupContractTx>>
   ): Promise<GraphQLClient.Transaction>;
   signMigrateRollupTokenTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupTokenTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupTokenTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signMintAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MintAssetTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signPauseRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.PauseRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signResumeRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ResumeRollupTx>>
   ): Promise<GraphQLClient.Transaction>;
-  signMintAssetTx(param: GraphQLClient.TxParam<GraphQLClient.MintAssetTx>): Promise<GraphQLClient.Transaction>;
-  signPauseRollupTx(param: GraphQLClient.TxParam<GraphQLClient.PauseRollupTx>): Promise<GraphQLClient.Transaction>;
-  signResumeRollupTx(param: GraphQLClient.TxParam<GraphQLClient.ResumeRollupTx>): Promise<GraphQLClient.Transaction>;
   signRevokeDelegateTx(
-    param: GraphQLClient.TxParam<GraphQLClient.RevokeDelegateTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeDelegateTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signRevokeStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.RevokeStakeTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signStakeTx(param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.StakeTx>>): Promise<GraphQLClient.Transaction>;
+  signTransferTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signTransferV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV2Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signTransferV3Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV3Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signUpdateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateAssetTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signUpdateRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  signUpgradeNodeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpgradeNodeTx>>
   ): Promise<GraphQLClient.Transaction>;
-  signRevokeStakeTx(param: GraphQLClient.TxParam<GraphQLClient.RevokeStakeTx>): Promise<GraphQLClient.Transaction>;
-  signStakeTx(param: GraphQLClient.TxParam<GraphQLClient.StakeTx>): Promise<GraphQLClient.Transaction>;
-  signTransferTx(param: GraphQLClient.TxParam<GraphQLClient.TransferTx>): Promise<GraphQLClient.Transaction>;
-  signTransferV2Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV2Tx>): Promise<GraphQLClient.Transaction>;
-  signTransferV3Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV3Tx>): Promise<GraphQLClient.Transaction>;
-  signUpdateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.UpdateAssetTx>): Promise<GraphQLClient.Transaction>;
-  signUpdateRollupTx(param: GraphQLClient.TxParam<GraphQLClient.UpdateRollupTx>): Promise<GraphQLClient.Transaction>;
-  signUpgradeNodeTx(param: GraphQLClient.TxParam<GraphQLClient.UpgradeNodeTx>): Promise<GraphQLClient.Transaction>;
   signWithdrawTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.WithdrawTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.WithdrawTokenV2Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignExchangeV2Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ExchangeV2Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignTransferV3Tx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.TransferV3Tx>>
   ): Promise<GraphQLClient.Transaction>;
-  multiSignExchangeV2Tx(param: GraphQLClient.TxParam<GraphQLClient.ExchangeV2Tx>): Promise<GraphQLClient.Transaction>;
-  multiSignTransferV3Tx(param: GraphQLClient.TxParam<GraphQLClient.TransferV3Tx>): Promise<GraphQLClient.Transaction>;
   multiSignAcquireAssetV3Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.AcquireAssetV3Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.AcquireAssetV3Tx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignStakeTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.StakeTx>>
   ): Promise<GraphQLClient.Transaction>;
-  multiSignStakeTx(param: GraphQLClient.TxParam<GraphQLClient.StakeTx>): Promise<GraphQLClient.Transaction>;
   multiSignUpdateRollupTx(
-    param: GraphQLClient.TxParam<GraphQLClient.UpdateRollupTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.UpdateRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignJoinRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.JoinRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignLeaveRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.LeaveRollupTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignPauseRollupTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.PauseRollupTx>>
   ): Promise<GraphQLClient.Transaction>;
-  multiSignJoinRollupTx(param: GraphQLClient.TxParam<GraphQLClient.JoinRollupTx>): Promise<GraphQLClient.Transaction>;
-  multiSignLeaveRollupTx(param: GraphQLClient.TxParam<GraphQLClient.LeaveRollupTx>): Promise<GraphQLClient.Transaction>;
-  multiSignPauseRollupTx(param: GraphQLClient.TxParam<GraphQLClient.PauseRollupTx>): Promise<GraphQLClient.Transaction>;
   multiSignResumeRollupTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ResumeRollupTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ResumeRollupTx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignDepositTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.DepositTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.DepositTokenV2Tx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignWithdrawTokenV2Tx(
-    param: GraphQLClient.TxParam<GraphQLClient.WithdrawTokenV2Tx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.WithdrawTokenV2Tx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignCreateRollupBlockTx(
-    param: GraphQLClient.TxParam<GraphQLClient.CreateRollupBlockTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateRollupBlockTx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignClaimBlockRewardTx(
-    param: GraphQLClient.TxParam<GraphQLClient.ClaimBlockRewardTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.ClaimBlockRewardTx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignMigrateRollupContractTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupContractTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupContractTx>>
   ): Promise<GraphQLClient.Transaction>;
   multiSignMigrateRollupTokenTx(
-    param: GraphQLClient.TxParam<GraphQLClient.MigrateRollupTokenTx>
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.MigrateRollupTokenTx>>
+  ): Promise<GraphQLClient.Transaction>;
+  multiSignCreateAssetTx(
+    param: GraphQLClient.TxParam<PartialDeep<GraphQLClient.CreateAssetTx>>
   ): Promise<GraphQLClient.Transaction>;
-  multiSignCreateAssetTx(param: GraphQLClient.TxParam<GraphQLClient.CreateAssetTx>): Promise<GraphQLClient.Transaction>;
   getAccountState(
     params: GraphQLClient.GetAccountStateParams
   ): GraphQLClient.QueryResult<GraphQLClient.ResponseGetAccountState>;
@@ -686,73 +855,61 @@ 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> {
-    tx: ItxParam<T>;
-    wallet: GraphQLClient.WalletObject;
-    delegator: string;
-    signature: string;
-  }
-
-  export interface ItxParam<T> {
-    nonce: number;
-    from: string;
-    pk: string;
-    chainId: string;
-    delegator: string;
-    signature: string;
-    signatures: array;
-    itx: T;
-  }
-
-  export interface WalletObject {
-    publicKey: string;
-    secretKey: string;
-    type: GraphQLClient.WalletTypeObject;
-    sign(message: string): string;
-    verify(message: string, signature: string): boolean;
-    toJSON(): object;
-    toAddress(): string;
+  interface TxParam<T> {
+    tx: {
+      nonce?: number;
+      from?: string;
+      pk?: string;
+      chainId?: string;
+      delegator?: string;
+      signature?: string;
+      signatures?: GraphQLClient.Multisig;
+      itx: T;
+    };
+    wallet: WalletObject;
+    delegator?: string;
+    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,
@@ -762,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,
@@ -793,7 +950,7 @@ declare namespace GraphQLClient {
     ROLE_ANY,
   }
 
-  export enum StatusCode {
+  enum StatusCode {
     OK,
     INVALID_NONCE,
     INVALID_SIGNATURE,
@@ -871,7 +1028,7 @@ declare namespace GraphQLClient {
     TIMEOUT,
   }
 
-  export enum UpgradeAction {
+  enum UpgradeAction {
     VERIFY,
     BACKUP,
     REPLACE,
@@ -886,7 +1043,7 @@ declare namespace GraphQLClient {
     DROP_ADDRESS_BOOK,
   }
 
-  export enum UpgradeType {
+  enum UpgradeType {
     CONFIG_APP,
     CONFIG_FORGE,
     CONFIG_DFS,
@@ -899,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;
@@ -1003,78 +1160,78 @@ declare namespace GraphQLClient {
     context: GraphQLClient.StateContext;
     issuer: string;
     gasBalance: string;
-    migratedTo: Array<null>;
-    migratedFrom: Array<null>;
+    migratedTo: string[];
+    migratedFrom: string[];
     numAssets: string;
-    tokens: Array<null>;
+    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<null>;
-    variables: Array<null>;
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
     issuer: GraphQLClient.NFTIssuer;
     data: GraphQLClient.Any;
   }
 
-  export interface AcquireAssetV3Tx {
+  interface AcquireAssetV3Tx {
     factory: string;
     address: string;
-    inputs: Array<null>;
+    inputs: GraphQLClient.TransactionInput[];
     owner: string;
-    variables: Array<null>;
+    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<null>;
-    assets: Array<null>;
-    variables: Array<null>;
+    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<null>;
+    trustedIssuers: string[];
     input: GraphQLClient.IndexedFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<null>;
+    hooks: GraphQLClient.AssetFactoryHook[];
     data: GraphQLClient.Any;
     context: GraphQLClient.StateContext;
     balance: string;
-    tokens: Array<null>;
+    tokens: GraphQLClient.IndexedTokenInput[];
     numMinted: number;
     display: GraphQLClient.NFTDisplay;
     lastSettlement: string;
   }
 
-  export interface AssetState {
+  interface AssetState {
     address: string;
     owner: string;
     moniker: string;
@@ -1086,27 +1243,27 @@ declare namespace GraphQLClient {
     parent: string;
     endpoint: GraphQLClient.NFTEndpoint;
     display: GraphQLClient.NFTDisplay;
-    tags: Array<null>;
+    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<null>;
+    txs: GraphQLClient.TransactionInfo[];
     totalTxs: string;
-    invalidTxs: Array<null>;
-    txsHashes: Array<null>;
-    invalidTxsHashes: Array<null>;
+    invalidTxs: GraphQLClient.TransactionInfo[];
+    txsHashes: string[];
+    invalidTxsHashes: string[];
     consensusHash: string;
     dataHash: string;
     evidenceHash: string;
@@ -1118,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<null>;
-    invalidTxsHashes: Array<null>;
+    txsHashes: string[];
+    invalidTxsHashes: string[];
     consensusHash: string;
     dataHash: string;
     evidenceHash: string;
@@ -1138,7 +1295,7 @@ declare namespace GraphQLClient {
     lastBlockId: GraphQLClient.BlockID;
   }
 
-  export interface ChainInfo {
+  interface ChainInfo {
     id: string;
     network: string;
     moniker: string;
@@ -1152,16 +1309,16 @@ declare namespace GraphQLClient {
     votingPower: string;
     totalTxs: string;
     version: string;
-    forgeAppsVersion: Array<null>;
-    supportedTxs: Array<null>;
+    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;
@@ -1170,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<null>;
-    validators: Array<null>;
+    pubKeyTypes: string[];
+    validators: GraphQLClient.Validator[];
     validatorChanged: boolean;
     paramChanged: boolean;
   }
 
-  export interface CreateAssetTx {
+  interface CreateAssetTx {
     moniker: string;
     data: GraphQLClient.Any;
     readonly: boolean;
@@ -1198,42 +1355,42 @@ declare namespace GraphQLClient {
     issuer: string;
     endpoint: GraphQLClient.NFTEndpoint;
     display: GraphQLClient.NFTDisplay;
-    tags: Array<null>;
+    tags: string[];
   }
 
-  export interface CreateFactoryTx {
+  interface CreateFactoryTx {
     name: string;
     description: string;
     settlement: string;
     limit: number;
-    trustedIssuers: Array<null>;
+    trustedIssuers: string[];
     input: GraphQLClient.AssetFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<null>;
+    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<null>;
+    txs: string[];
     proposer: string;
-    signatures: Array<null>;
+    signatures: GraphQLClient.Multisig[];
     rollup: string;
     minReward: string;
     data: GraphQLClient.Any;
   }
 
-  export interface CreateRollupTx {
+  interface CreateRollupTx {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<null>;
+    seedValidators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -1263,7 +1420,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface CreateTokenTx {
+  interface CreateTokenTx {
     name: string;
     description: string;
     symbol: string;
@@ -1277,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<null>;
+    typeUrls: string[];
   }
 
-  export interface DelegateOp {
+  interface DelegateOp {
     typeUrl: string;
-    rules: Array<null>;
+    rules: string[];
   }
 
-  export interface DelegateOpState {
+  interface DelegateOpState {
     rule: string;
     numTxs: number;
     numTxsDelta: number;
@@ -1301,26 +1458,26 @@ declare namespace GraphQLClient {
     balanceDelta: string;
   }
 
-  export interface DelegateState {
+  interface DelegateState {
     address: string;
-    ops: Array<null>;
+    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<null>;
+    ops: GraphQLClient.DelegateOp[];
     data: GraphQLClient.Any;
   }
 
-  export interface DepositTokenV2Tx {
+  interface DepositTokenV2Tx {
     token: GraphQLClient.TokenInput;
     to: string;
     proposer: string;
@@ -1330,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<null>;
+    assets: string[];
   }
 
-  export interface ExchangeInfoV2 {
+  interface ExchangeInfoV2 {
     value: string;
-    assets: Array<null>;
-    tokens: Array<null>;
+    assets: string[];
+    tokens: GraphQLClient.TokenInput[];
   }
 
-  export interface ExchangeTx {
+  interface ExchangeTx {
     to: string;
     sender: GraphQLClient.ExchangeInfo;
     receiver: GraphQLClient.ExchangeInfo;
@@ -1359,7 +1516,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ExchangeV2Tx {
+  interface ExchangeV2Tx {
     to: string;
     sender: GraphQLClient.ExchangeInfoV2;
     receiver: GraphQLClient.ExchangeInfoV2;
@@ -1367,7 +1524,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface ForeignToken {
+  interface ForeignToken {
     type: string;
     contractAddress: string;
     chainType: string;
@@ -1375,46 +1532,46 @@ declare namespace GraphQLClient {
     chainId: number;
   }
 
-  export interface ForgeState {
+  interface ForgeState {
     address: string;
     consensus: GraphQLClient.ConsensusParams;
-    tasks: Array<null>;
+    tasks: GraphQLClient.ForgeState_TasksEntry[];
     version: string;
     token: GraphQLClient.ForgeToken;
     txConfig: GraphQLClient.TransactionConfig;
     upgradeInfo: GraphQLClient.UpgradeInfo;
-    accountConfig: Array<null>;
+    accountConfig: GraphQLClient.AccountConfig[];
     data: GraphQLClient.Any;
   }
 
-  export interface ForgeState_TasksEntry {
+  interface ForgeState_TasksEntry {
     key: number;
     value: GraphQLClient.UpgradeTasks;
   }
 
-  export interface ForgeStats {
-    numBlocks: Array<null>;
-    numTxs: Array<null>;
-    numStakes: Array<null>;
-    numValidators: Array<null>;
-    numAccountMigrateTxs: Array<null>;
-    numCreateAssetTxs: Array<null>;
-    numConsensusUpgradeTxs: Array<null>;
-    numDeclareTxs: Array<null>;
-    numDeclareFileTxs: Array<null>;
-    numExchangeTxs: Array<null>;
-    numStakeTxs: Array<null>;
-    numSysUpgradeTxs: Array<null>;
-    numTransferTxs: Array<null>;
-    numUpdateAssetTxs: Array<null>;
-    numConsumeAssetTxs: Array<null>;
-    tps: Array<null>;
+  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;
@@ -1427,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;
@@ -1448,11 +1605,11 @@ declare namespace GraphQLClient {
     totalReceivedStakes: string;
     totalStakes: string;
     totalUnstakes: string;
-    recentNumTxs: Array<null>;
-    tokens: Array<null>;
+    recentNumTxs: string[];
+    tokens: GraphQLClient.TokenInfo[];
   }
 
-  export interface IndexedAssetState {
+  interface IndexedAssetState {
     address: string;
     owner: string;
     genesisTime: string;
@@ -1466,11 +1623,11 @@ declare namespace GraphQLClient {
     ttl: string;
     display: GraphQLClient.NFTDisplay;
     endpoint: GraphQLClient.NFTEndpoint;
-    tags: Array<null>;
+    tags: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedBlock {
+  interface IndexedBlock {
     height: string;
     time: string;
     proposer: string;
@@ -1478,27 +1635,27 @@ declare namespace GraphQLClient {
     numInvalidTxs: string;
   }
 
-  export interface IndexedFactoryInput {
+  interface IndexedFactoryInput {
     value: string;
-    tokens: Array<null>;
-    assets: Array<null>;
-    variables: Array<null>;
+    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<null>;
+    trustedIssuers: string[];
     input: GraphQLClient.IndexedFactoryInput;
     output: GraphQLClient.CreateAssetTx;
-    hooks: Array<null>;
+    hooks: GraphQLClient.AssetFactoryHook[];
     data: GraphQLClient.Any;
     balance: string;
-    tokens: Array<null>;
+    tokens: GraphQLClient.TokenInfo[];
     numMinted: number;
     lastSettlement: string;
     genesisTime: string;
@@ -1506,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<null>;
+    txs: string[];
     proposer: string;
-    signatures: Array<null>;
+    signatures: GraphQLClient.Multisig[];
     genesisTime: string;
     renaissanceTime: string;
     rollup: string;
@@ -1525,12 +1682,12 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedRollupState {
+  interface IndexedRollupState {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<null>;
-    validators: Array<null>;
+    seedValidators: GraphQLClient.RollupValidator[];
+    validators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -1564,11 +1721,11 @@ declare namespace GraphQLClient {
     publisherFeeShare: number;
     publishWaitingPeriod: number;
     publishSlashRate: number;
-    migrateHistory: Array<null>;
+    migrateHistory: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedRollupValidator {
+  interface IndexedRollupValidator {
     pk: string;
     address: string;
     moniker: string;
@@ -1588,23 +1745,23 @@ declare namespace GraphQLClient {
     rollup: string;
   }
 
-  export interface IndexedStakeState {
+  interface IndexedStakeState {
     address: string;
     sender: string;
     receiver: string;
-    tokens: Array<null>;
-    assets: Array<null>;
+    tokens: GraphQLClient.TokenInfo[];
+    assets: string[];
     revocable: boolean;
     genesisTime: string;
     renaissanceTime: string;
     message: string;
     revokeWaitingPeriod: number;
-    revokedTokens: Array<null>;
-    revokedAssets: Array<null>;
+    revokedTokens: GraphQLClient.TokenInfo[];
+    revokedAssets: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedTokenInput {
+  interface IndexedTokenInput {
     address: string;
     value: string;
     decimal: number;
@@ -1612,7 +1769,7 @@ declare namespace GraphQLClient {
     symbol: string;
   }
 
-  export interface IndexedTokenState {
+  interface IndexedTokenState {
     name: string;
     description: string;
     symbol: string;
@@ -1628,7 +1785,7 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface IndexedTransaction {
+  interface IndexedTransaction {
     hash: string;
     sender: string;
     receiver: string;
@@ -1637,37 +1794,37 @@ declare namespace GraphQLClient {
     tx: GraphQLClient.Transaction;
     valid: boolean;
     code: string;
-    tokenSymbols: Array<null>;
-    receipts: Array<null>;
+    tokenSymbols: GraphQLClient.TokenSymbol[];
+    receipts: GraphQLClient.TransactionReceipt[];
   }
 
-  export interface JoinRollupTx {
+  interface JoinRollupTx {
     rollup: string;
     endpoint: string;
     evidence: GraphQLClient.Evidence;
-    signatures: Array<null>;
+    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<null>;
+    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;
@@ -1675,16 +1832,16 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface MintAssetTx {
+  interface MintAssetTx {
     factory: string;
     address: string;
-    assets: Array<null>;
-    variables: Array<null>;
+    assets: string[];
+    variables: GraphQLClient.VariableInput[];
     owner: string;
     data: GraphQLClient.Any;
   }
 
-  export interface Multisig {
+  interface Multisig {
     signer: string;
     pk: string;
     signature: string;
@@ -1692,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<null>;
+    listeners: string[];
     nPeers: number;
-    peers: Array<null>;
+    peers: GraphQLClient.PeerInfo[];
   }
 
-  export interface NodeInfo {
+  interface NodeInfo {
     id: string;
     network: string;
     moniker: string;
@@ -1729,35 +1886,35 @@ declare namespace GraphQLClient {
     votingPower: string;
     totalTxs: string;
     version: string;
-    forgeAppsVersion: Array<null>;
-    supportedTxs: Array<null>;
+    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;
@@ -1766,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<null>;
+    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<null>;
+    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<null>;
+    transactions: GraphQLClient.IndexedTransaction[];
   }
 
-  export interface ResponseListAssets {
+  interface ResponseListAssets {
     code: string;
     page: GraphQLClient.PageInfo;
-    assets: Array<null>;
+    assets: GraphQLClient.IndexedAssetState[];
   }
 
-  export interface ResponseListBlocks {
+  interface ResponseListBlocks {
     code: string;
     page: GraphQLClient.PageInfo;
-    blocks: Array<null>;
+    blocks: GraphQLClient.IndexedBlock[];
   }
 
-  export interface ResponseListFactories {
+  interface ResponseListFactories {
     code: string;
     page: GraphQLClient.PageInfo;
-    factories: Array<null>;
+    factories: GraphQLClient.IndexedFactoryState[];
   }
 
-  export interface ResponseListRollupBlocks {
+  interface ResponseListRollupBlocks {
     code: string;
     page: GraphQLClient.PageInfo;
-    blocks: Array<null>;
+    blocks: GraphQLClient.IndexedRollupBlock[];
   }
 
-  export interface ResponseListRollupValidators {
+  interface ResponseListRollupValidators {
     code: string;
     page: GraphQLClient.PageInfo;
-    validators: Array<null>;
+    validators: GraphQLClient.IndexedRollupValidator[];
   }
 
-  export interface ResponseListRollups {
+  interface ResponseListRollups {
     code: string;
     page: GraphQLClient.PageInfo;
-    rollups: Array<null>;
+    rollups: GraphQLClient.IndexedRollupState[];
   }
 
-  export interface ResponseListStakes {
+  interface ResponseListStakes {
     code: string;
     page: GraphQLClient.PageInfo;
-    stakes: Array<null>;
+    stakes: GraphQLClient.IndexedStakeState[];
   }
 
-  export interface ResponseListTokens {
+  interface ResponseListTokens {
     code: string;
     page: GraphQLClient.PageInfo;
-    tokens: Array<null>;
+    tokens: GraphQLClient.IndexedTokenState[];
   }
 
-  export interface ResponseListTopAccounts {
+  interface ResponseListTopAccounts {
     code: string;
     page: GraphQLClient.PageInfo;
-    accounts: Array<null>;
+    accounts: GraphQLClient.IndexedAccountState[];
   }
 
-  export interface ResponseListTransactions {
+  interface ResponseListTransactions {
     code: string;
     page: GraphQLClient.PageInfo;
-    transactions: Array<null>;
+    transactions: GraphQLClient.IndexedTransaction[];
   }
 
-  export interface ResponseSearch {
+  interface ResponseSearch {
     code: string;
     page: GraphQLClient.PageInfo;
-    results: Array<null>;
+    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<null>;
+    typeUrls: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface RevokeStakeTx {
+  interface RevokeStakeTx {
     address: string;
-    outputs: Array<null>;
+    outputs: GraphQLClient.TransactionInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface RollupBlock {
+  interface RollupBlock {
     hash: string;
     height: number;
     merkleRoot: string;
     previousHash: string;
     txsHash: string;
-    txs: Array<null>;
+    txs: string[];
     proposer: string;
-    signatures: Array<null>;
+    signatures: GraphQLClient.Multisig[];
     rollup: string;
     mintedAmount: string;
     burnedAmount: string;
@@ -1996,12 +2153,12 @@ declare namespace GraphQLClient {
     data: GraphQLClient.Any;
   }
 
-  export interface RollupState {
+  interface RollupState {
     address: string;
     tokenAddress: string;
     contractAddress: string;
-    seedValidators: Array<null>;
-    validators: Array<null>;
+    seedValidators: GraphQLClient.RollupValidator[];
+    validators: GraphQLClient.RollupValidator[];
     minStakeAmount: string;
     maxStakeAmount: string;
     minSignerCount: number;
@@ -2033,55 +2190,55 @@ declare namespace GraphQLClient {
     leaveWaitingPeriod: number;
     publishWaitingPeriod: number;
     publishSlashRate: number;
-    migrateHistory: Array<null>;
+    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<null>;
-    assets: Array<null>;
+    tokens: GraphQLClient.IndexedTokenInput[];
+    assets: string[];
     revocable: boolean;
     message: string;
     revokeWaitingPeriod: number;
-    revokedTokens: Array<null>;
-    revokedAssets: Array<null>;
+    revokedTokens: GraphQLClient.IndexedTokenInput[];
+    revokedAssets: string[];
     context: GraphQLClient.StateContext;
     data: GraphQLClient.Any;
   }
 
-  export interface StakeTx {
+  interface StakeTx {
     address: string;
     receiver: string;
-    inputs: Array<null>;
+    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;
@@ -2089,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;
@@ -2109,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<Multisig>;
+    signatures: GraphQLClient.Multisig[];
     itxJson: undefined;
     sender: string;
     receiver: string;
@@ -2132,67 +2289,67 @@ declare namespace GraphQLClient {
     gasPaid: string;
   }
 
-  export interface TransactionConfig {
+  interface TransactionConfig {
     maxAssetSize: number;
     maxListSize: number;
     maxMultisig: number;
     delegate: GraphQLClient.DelegateConfig;
-    txFee: Array<null>;
+    txFee: GraphQLClient.TxFeeConfig[];
     txGas: GraphQLClient.TxGasConfig;
   }
 
-  export interface TransactionInfo {
+  interface TransactionInfo {
     tx: GraphQLClient.Transaction;
     height: string;
     index: number;
     hash: string;
-    tags: Array<null>;
+    tags: GraphQLClient.KVPair[];
     code: string;
     time: string;
-    receipts: Array<null>;
+    receipts: GraphQLClient.TransactionReceipt[];
     sender: string;
     receiver: string;
-    tokenSymbols: Array<null>;
+    tokenSymbols: GraphQLClient.TokenSymbol[];
   }
 
-  export interface TransactionInput {
+  interface TransactionInput {
     owner: string;
-    tokens: Array<null>;
-    assets: Array<null>;
+    tokens: GraphQLClient.TokenInput[];
+    assets: string[];
   }
 
-  export interface TransactionReceipt {
+  interface TransactionReceipt {
     address: string;
-    changes: Array<null>;
+    changes: GraphQLClient.ReceiptChange[];
   }
 
-  export interface TransferTx {
+  interface TransferTx {
     to: string;
     value: string;
-    assets: Array<null>;
+    assets: string[];
     data: GraphQLClient.Any;
   }
 
-  export interface TransferV2Tx {
+  interface TransferV2Tx {
     to: string;
     value: string;
-    assets: Array<null>;
-    tokens: Array<null>;
+    assets: string[];
+    tokens: GraphQLClient.TokenInput[];
     data: GraphQLClient.Any;
   }
 
-  export interface TransferV3Tx {
-    inputs: Array<null>;
-    outputs: Array<null>;
+  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;
@@ -2202,18 +2359,18 @@ declare namespace GraphQLClient {
     stakeLockPeriod: number;
   }
 
-  export interface UnconfirmedTxs {
+  interface UnconfirmedTxs {
     nTxs: number;
-    txs: Array<null>;
+    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;
@@ -2241,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<null>;
+    actions: GraphQLClient.UpgradeAction[];
   }
 
-  export interface UpgradeTasks {
-    item: Array<null>;
+  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;
@@ -2276,31 +2433,31 @@ declare namespace GraphQLClient {
     geoInfo: GraphQLClient.GeoInfo;
   }
 
-  export interface ValidatorsInfo {
+  interface ValidatorsInfo {
     blockHeight: string;
-    validators: Array<null>;
+    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;
@@ -2310,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;
@@ -2388,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;
@@ -2407,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;
@@ -2464,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;