@alephium/web3 1.7.3 → 1.8.0

package/dist/src/api/api-alephium.d.ts

@@ -161,6 +161,40 @@ export interface BrokerInfo {
         port: number;
     };
 }
+/** BuildChainedDeployContractTx */
+export interface BuildChainedDeployContractTx {
+    value: BuildDeployContractTx;
+    type: string;
+}
+/** BuildChainedDeployContractTxResult */
+export interface BuildChainedDeployContractTxResult {
+    value: BuildDeployContractTxResult;
+    type: string;
+}
+/** BuildChainedExecuteScriptTx */
+export interface BuildChainedExecuteScriptTx {
+    value: BuildExecuteScriptTx;
+    type: string;
+}
+/** BuildChainedExecuteScriptTxResult */
+export interface BuildChainedExecuteScriptTxResult {
+    value: BuildExecuteScriptTxResult;
+    type: string;
+}
+/** BuildChainedTransferTx */
+export interface BuildChainedTransferTx {
+    value: BuildTransferTx;
+    type: string;
+}
+/** BuildChainedTransferTxResult */
+export interface BuildChainedTransferTxResult {
+    value: BuildTransferTxResult;
+    type: string;
+}
+/** BuildChainedTx */
+export type BuildChainedTx = BuildChainedDeployContractTx | BuildChainedExecuteScriptTx | BuildChainedTransferTx;
+/** BuildChainedTxResult */
+export type BuildChainedTxResult = BuildChainedDeployContractTxResult | BuildChainedExecuteScriptTxResult | BuildChainedTransferTxResult;
 /** BuildDeployContractTx */
 export interface BuildDeployContractTx {
     /** @format hex-string */
@@ -313,8 +347,8 @@ export interface BuildSweepMultisig {
     /** @format block-hash */
     targetBlockHash?: string;
 }
-/** BuildTransaction */
-export interface BuildTransaction {
+/** BuildTransferTx */
+export interface BuildTransferTx {
     /** @format hex-string */
     fromPublicKey: string;
     /** @format hex-string */
@@ -328,8 +362,8 @@ export interface BuildTransaction {
     /** @format block-hash */
     targetBlockHash?: string;
 }
-/** BuildTransactionResult */
-export interface BuildTransactionResult {
+/** BuildTransferTxResult */
+export interface BuildTransferTxResult {
     unsignedTx: string;
     /** @format gas */
     gasAmount: number;
@@ -818,6 +852,90 @@ export interface RevealMnemonic {
 export interface RevealMnemonicResult {
     mnemonic: string;
 }
+/** RichAssetInput */
+export interface RichAssetInput {
+    /** @format int32 */
+    hint: number;
+    /** @format 32-byte-hash */
+    key: string;
+    /** @format hex-string */
+    unlockScript: string;
+    /** @format uint256 */
+    attoAlphAmount: string;
+    /** @format address */
+    address: string;
+    tokens: Token[];
+}
+/** RichBlockAndEvents */
+export interface RichBlockAndEvents {
+    block: RichBlockEntry;
+    events: ContractEventByBlockHash[];
+}
+/** RichBlockEntry */
+export interface RichBlockEntry {
+    /** @format block-hash */
+    hash: string;
+    /** @format int64 */
+    timestamp: number;
+    /** @format int32 */
+    chainFrom: number;
+    /** @format int32 */
+    chainTo: number;
+    /** @format int32 */
+    height: number;
+    deps: string[];
+    transactions: RichTransaction[];
+    /** @format hex-string */
+    nonce: string;
+    version: number;
+    /** @format 32-byte-hash */
+    depStateHash: string;
+    /** @format 32-byte-hash */
+    txsHash: string;
+    /** @format hex-string */
+    target: string;
+    ghostUncles: GhostUncleBlockEntry[];
+}
+/** RichBlocksAndEventsPerTimeStampRange */
+export interface RichBlocksAndEventsPerTimeStampRange {
+    blocksAndEvents: RichBlockAndEvents[][];
+}
+/** RichContractInput */
+export interface RichContractInput {
+    /** @format int32 */
+    hint: number;
+    /** @format 32-byte-hash */
+    key: string;
+    /** @format uint256 */
+    attoAlphAmount: string;
+    /** @format address */
+    address: string;
+    tokens: Token[];
+}
+/** RichTransaction */
+export interface RichTransaction {
+    unsigned: RichUnsignedTx;
+    scriptExecutionOk: boolean;
+    contractInputs: RichContractInput[];
+    generatedOutputs: Output[];
+    inputSignatures: string[];
+    scriptSignatures: string[];
+}
+/** RichUnsignedTx */
+export interface RichUnsignedTx {
+    /** @format 32-byte-hash */
+    txId: string;
+    version: number;
+    networkId: number;
+    /** @format script */
+    scriptOpt?: string;
+    /** @format int32 */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    inputs: RichAssetInput[];
+    fixedOutputs: FixedAssetOutput[];
+}
 /** Script */
 export interface Script {
     code: string;
@@ -986,6 +1104,8 @@ export interface TransactionTemplate {
     unsigned: UnsignedTx;
     inputSignatures: string[];
     scriptSignatures: string[];
+    /** @format int64 */
+    seenAt: number;
 }
 /** Transfer */
 export interface Transfer {
@@ -1205,7 +1325,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 3.6.2
+ * @version 3.8.1
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1562,6 +1682,26 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              */
             toTs?: number;
         }, params?: RequestParams) => Promise<BlocksAndEventsPerTimeStampRange>;
+        /**
+         * No description
+         *
+         * @tags Blockflow
+         * @name GetBlockflowRichBlocks
+         * @summary Given a time interval, list blocks containing events and transactions with enriched input information when node indexes are enabled.
+         * @request GET:/blockflow/rich-blocks
+         */
+        getBlockflowRichBlocks: (query: {
+            /**
+             * @format int64
+             * @min 0
+             */
+            fromTs: number;
+            /**
+             * @format int64
+             * @min 0
+             */
+            toTs?: number;
+        }, params?: RequestParams) => Promise<RichBlocksAndEventsPerTimeStampRange>;
         /**
          * No description
          *
@@ -1589,6 +1729,15 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/blockflow/blocks-with-events/{block_hash}
          */
         getBlockflowBlocksWithEventsBlockHash: (blockHash: string, params?: RequestParams) => Promise<BlockAndEvents>;
+        /**
+         * No description
+         *
+         * @tags Blockflow
+         * @name GetBlockflowRichBlocksBlockHash
+         * @summary Get a block containing events and transactions with enriched input information when node indexes are enabled.
+         * @request GET:/blockflow/rich-blocks/{block_hash}
+         */
+        getBlockflowRichBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<RichBlockAndEvents>;
         /**
          * No description
          *
@@ -1687,10 +1836,10 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          *
          * @tags Transactions
          * @name PostTransactionsBuild
-         * @summary Build an unsigned transaction to a number of recipients
+         * @summary Build an unsigned transfer transaction to a number of recipients
          * @request POST:/transactions/build
          */
-        postTransactionsBuild: (data: BuildTransaction, params?: RequestParams) => Promise<BuildTransactionResult>;
+        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult>;
         /**
          * No description
          *
@@ -1699,7 +1848,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned transaction with multiple addresses to a number of recipients
          * @request POST:/transactions/build-multi-addresses
          */
-        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildTransactionResult>;
+        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildTransferTxResult>;
         /**
          * No description
          *
@@ -1741,6 +1890,20 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             /** @format int32 */
             toGroup?: number;
         }, params?: RequestParams) => Promise<Transaction>;
+        /**
+         * No description
+         *
+         * @tags Transactions
+         * @name GetTransactionsRichDetailsTxid
+         * @summary Get transaction with enriched input information when node indexes are enabled.
+         * @request GET:/transactions/rich-details/{txId}
+         */
+        getTransactionsRichDetailsTxid: (txId: string, query?: {
+            /** @format int32 */
+            fromGroup?: number;
+            /** @format int32 */
+            toGroup?: number;
+        }, params?: RequestParams) => Promise<RichTransaction>;
         /**
          * No description
          *
@@ -1785,6 +1948,15 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             /** @format 32-byte-hash */
             key: string;
         }, params?: RequestParams) => Promise<string>;
+        /**
+         * No description
+         *
+         * @tags Transactions
+         * @name PostTransactionsBuildChained
+         * @summary Build a chain of transactions
+         * @request POST:/transactions/build-chained
+         */
+        postTransactionsBuildChained: (data: BuildChainedTx[], params?: RequestParams) => Promise<BuildChainedTxResult[]>;
     };
     mempool: {
         /**
@@ -1969,7 +2141,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build a multisig unsigned transaction
          * @request POST:/multisig/build
          */
-        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildTransactionResult>;
+        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildTransferTxResult>;
         /**
          * No description
          *

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 3.6.2
+ * @version 3.8.1
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -661,6 +661,21 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Blockflow
+             * @name GetBlockflowRichBlocks
+             * @summary Given a time interval, list blocks containing events and transactions with enriched input information when node indexes are enabled.
+             * @request GET:/blockflow/rich-blocks
+             */
+            getBlockflowRichBlocks: (query, params = {}) => this.request({
+                path: `/blockflow/rich-blocks`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -703,6 +718,20 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Blockflow
+             * @name GetBlockflowRichBlocksBlockHash
+             * @summary Get a block containing events and transactions with enriched input information when node indexes are enabled.
+             * @request GET:/blockflow/rich-blocks/{block_hash}
+             */
+            getBlockflowRichBlocksBlockHash: (blockHash, params = {}) => this.request({
+                path: `/blockflow/rich-blocks/${blockHash}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -828,7 +857,7 @@ class Api extends HttpClient {
              *
              * @tags Transactions
              * @name PostTransactionsBuild
-             * @summary Build an unsigned transaction to a number of recipients
+             * @summary Build an unsigned transfer transaction to a number of recipients
              * @request POST:/transactions/build
              */
             postTransactionsBuild: (data, params = {}) => this.request({
@@ -918,6 +947,21 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Transactions
+             * @name GetTransactionsRichDetailsTxid
+             * @summary Get transaction with enriched input information when node indexes are enabled.
+             * @request GET:/transactions/rich-details/{txId}
+             */
+            getTransactionsRichDetailsTxid: (txId, query, params = {}) => this.request({
+                path: `/transactions/rich-details/${txId}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -962,6 +1006,22 @@ class Api extends HttpClient {
                 query: query,
                 format: 'json',
                 ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Transactions
+             * @name PostTransactionsBuildChained
+             * @summary Build a chain of transactions
+             * @request POST:/transactions/build-chained
+             */
+            postTransactionsBuildChained: (data, params = {}) => this.request({
+                path: `/transactions/build-chained`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
             }).then(utils_1.convertHttpResponse)
         };
         this.mempool = {

package/dist/src/api/api-explorer.d.ts

@@ -162,6 +162,7 @@ export interface AssetOutput {
 }
 /** NFT */
 export interface NFT {
+    id: string;
     type: string;
 }
 /** AcceptedTransaction */
@@ -187,6 +188,13 @@ export interface AcceptedTransaction {
     /** @format int64 */
     timestamp: number;
 }
+/** HolderInfo */
+export interface HolderInfo {
+    /** @format address */
+    address: string;
+    /** @format uint256 */
+    balance: string;
+}
 /** TokenSupply */
 export interface TokenSupply {
     /** @format uint256 */
@@ -278,6 +286,8 @@ export declare enum TokenStdInterfaceId {
 export interface ExplorerInfo {
     releaseVersion: string;
     commit: string;
+    /** @format int64 */
+    lastHoldersUpdate: number;
     /** @format int32 */
     migrationsVersion: number;
     /** @format int64 */
@@ -323,6 +333,7 @@ export interface Transaction {
 }
 /** FungibleToken */
 export interface FungibleToken {
+    id: string;
     type: string;
 }
 /** GhostUncle */
@@ -1045,6 +1056,28 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              */
             'interface-id'?: TokenStdInterfaceId | string;
         }, params?: RequestParams) => Promise<TokenInfo[]>;
+        /**
+         * @description Get a sorted list of top addresses by {token_id} balance. Updates once per day.
+         *
+         * @tags Tokens
+         * @name GetTokensHoldersTokenTokenId
+         * @request GET:/tokens/holders/token/{token_id}
+         */
+        getTokensHoldersTokenTokenId: (tokenId: string, query?: {
+            /**
+             * Page number
+             * @format int32
+             * @min 1
+             */
+            page?: number;
+            /**
+             * Number of items per page
+             * @format int32
+             * @min 0
+             * @max 100
+             */
+            limit?: number;
+        }, params?: RequestParams) => Promise<HolderInfo[]>;
         /**
          * @description List token transactions
          *
@@ -1097,6 +1130,28 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
              */
             limit?: number;
         }, params?: RequestParams) => Promise<string[]>;
+        /**
+         * @description Get a sorted list of top addresses by ALPH balance. Updates once per day.
+         *
+         * @tags Tokens
+         * @name GetTokensHoldersAlph
+         * @request GET:/tokens/holders/alph
+         */
+        getTokensHoldersAlph: (query?: {
+            /**
+             * Page number
+             * @format int32
+             * @min 1
+             */
+            page?: number;
+            /**
+             * Number of items per page
+             * @format int32
+             * @min 0
+             * @max 100
+             */
+            limit?: number;
+        }, params?: RequestParams) => Promise<HolderInfo[]>;
         /**
          * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
          *

package/dist/src/api/api-explorer.js

@@ -680,6 +680,20 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get a sorted list of top addresses by {token_id} balance. Updates once per day.
+             *
+             * @tags Tokens
+             * @name GetTokensHoldersTokenTokenId
+             * @request GET:/tokens/holders/token/{token_id}
+             */
+            getTokensHoldersTokenTokenId: (tokenId, query, params = {}) => this.request({
+                path: `/tokens/holders/token/${tokenId}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * @description List token transactions
              *
@@ -723,6 +737,20 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get a sorted list of top addresses by ALPH balance. Updates once per day.
+             *
+             * @tags Tokens
+             * @name GetTokensHoldersAlph
+             * @request GET:/tokens/holders/alph
+             */
+            getTokensHoldersAlph: (query, params = {}) => this.request({
+                path: `/tokens/holders/alph`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
              *

package/dist/src/contract/contract.d.ts

@@ -303,7 +303,9 @@ export declare function subscribeContractEvent<F extends Fields, M extends Contr
 export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: EventSubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
 export declare function signExecuteMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<SignExecuteContractMethodParams<A>, 'args'>): Promise<SignExecuteScriptTxResult>;
-export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, callss: Record<string, Optional<CallContractParams<any>, 'args'>>[], getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>[] | Record<string, CallContractResult<any>>>;
+type Calls = Record<string, Optional<CallContractParams<any>, 'args'>>;
+export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, _callss: Calls | Calls[], getContractByCodeHash: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>[] | Record<string, CallContractResult<any>>>;
 export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export declare const getContractIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
 export declare const getTokenIdFromUnsignedTx: (nodeProvider: NodeProvider, unsignedTx: string) => Promise<HexString>;
+export {};

package/dist/src/contract/contract.js

@@ -1328,7 +1328,8 @@ function toFieldsSig(contractName, functionSig) {
         isMutable: [false].concat(functionSig.paramIsMutable)
     };
 }
-async function multicallMethods(contract, instance, callss, getContractByCodeHash) {
+async function multicallMethods(contract, instance, _callss, getContractByCodeHash) {
+    const callss = Array.isArray(_callss) ? _callss : [_callss];
     const callEntries = callss.map((calls) => Object.entries(calls));
     const callsParams = callEntries.map((entries) => {
         return entries.map((entry) => {
@@ -1340,7 +1341,7 @@ async function multicallMethods(contract, instance, callss, getContractByCodeHas
     });
     const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsMulticallContract({ calls: callsParams.flat() });
     let callResultIndex = 0;
-    return callsParams.map((calls, index0) => {
+    const results = callsParams.map((calls, index0) => {
         const callsResult = {};
         const entries = callEntries[`${index0}`];
         calls.forEach((call, index1) => {
@@ -1352,6 +1353,7 @@ async function multicallMethods(contract, instance, callss, getContractByCodeHas
         });
         return callsResult;
     });
+    return Array.isArray(_callss) ? results : results[0];
 }
 exports.multicallMethods = multicallMethods;
 async function getContractEventsCurrentCount(contractAddress) {

package/dist/src/signer/signer.d.ts

@@ -1,6 +1,6 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher } from './types';
+import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher, SignChainedTxParams, SignChainedTxResult } from './types';
 export declare abstract class SignerProvider {
     abstract get nodeProvider(): NodeProvider | undefined;
     abstract get explorerProvider(): ExplorerProvider | undefined;
@@ -11,6 +11,7 @@ export declare abstract class SignerProvider {
     abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
     abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    abstract signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
     abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     abstract signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
@@ -26,14 +27,16 @@ export declare abstract class SignerProviderSimple extends SignerProvider {
     signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
     signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signAndSubmitChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
     protected abstract getPublicKey(address: string): Promise<string>;
-    private usePublicKey;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>>;
     signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
     buildDeployContractTx(params: SignDeployContractTxParams): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
     signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
     buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
+    signChainedTx(params: SignChainedTxParams[]): Promise<SignChainedTxResult[]>;
+    buildChainedTx(params: SignChainedTxParams[]): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
     signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
     abstract signRaw(signerAddress: string, hexString: string): Promise<string>;

package/dist/src/signer/signer.js

@@ -99,10 +99,12 @@ class SignerProviderSimple extends SignerProvider {
         await this.submitTransaction(signResult);
         return signResult;
     }
-    async usePublicKey(params) {
-        const { signerAddress, ...restParams } = params;
-        const publicKey = await this.getPublicKey(signerAddress);
-        return { fromPublicKey: publicKey, ...restParams };
+    async signAndSubmitChainedTx(params) {
+        const signResults = await this.signChainedTx(params);
+        for (const r of signResults) {
+            await this.submitTransaction(r);
+        }
+        return signResults;
     }
     async signTransferTx(params) {
         const response = await this.buildTransferTx(params);
@@ -128,6 +130,14 @@ class SignerProviderSimple extends SignerProvider {
     async buildExecuteScriptTx(params) {
         return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress));
     }
+    async signChainedTx(params) {
+        const response = await this.buildChainedTx(params);
+        const signatures = await Promise.all(response.map((r, i) => this.signRaw(params[`${i}`].signerAddress, r.txId)));
+        return response.map((r, i) => ({ ...r, signature: signatures[`${i}`] }));
+    }
+    async buildChainedTx(params) {
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildChainedTx(params, await Promise.all(params.map((p) => this.getPublicKey(p.signerAddress))));
+    }
     // in general, wallet should show the decoded information to user for confirmation
     // please overwrite this function for real wallet
     async signUnsignedTx(params) {

package/dist/src/signer/tx-builder.d.ts

@@ -1,5 +1,5 @@
 import { NodeProvider } from '../api';
-import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult } from './types';
+import { SignChainedTxParams, SignChainedTxResult, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult } from './types';
 export declare abstract class TransactionBuilder {
     abstract get nodeProvider(): NodeProvider;
     static from(nodeProvider: NodeProvider): TransactionBuilder;
@@ -8,5 +8,12 @@ export declare abstract class TransactionBuilder {
     buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<Omit<SignTransferTxResult, 'signature'>>;
     buildDeployContractTx(params: SignDeployContractTxParams, publicKey: string): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
     buildExecuteScriptTx(params: SignExecuteScriptTxParams, publicKey: string): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
+    buildChainedTx(params: SignChainedTxParams[], publicKeys: string[]): Promise<Omit<SignChainedTxResult, 'signature'>[]>;
     buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'>;
+    private buildTransferTxParams;
+    private buildDeployContractTxParams;
+    private buildExecuteScriptTxParams;
+    private convertTransferTxResult;
+    private convertDeployContractTxResult;
+    private convertExecuteScriptTxResult;
 }