@alephium/web3 1.7.4 → 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;
@@ -1070,6 +1104,8 @@ export interface TransactionTemplate {
     unsigned: UnsignedTx;
     inputSignatures: string[];
     scriptSignatures: string[];
+    /** @format int64 */
+    seenAt: number;
 }
 /** Transfer */
 export interface Transfer {
@@ -1289,7 +1325,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 3.7.0
+ * @version 3.8.1
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1800,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
          *
@@ -1812,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
          *
@@ -1854,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
          *
@@ -1898,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: {
         /**
@@ -2082,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.7.0
+ * @version 3.8.1
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -857,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({
@@ -947,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
              *
@@ -991,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/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;
 }

package/dist/src/signer/tx-builder.js

@@ -41,22 +41,103 @@ class TransactionBuilder {
         }
     }
     async buildTransferTx(params, publicKey) {
+        const data = this.buildTransferTxParams(params, publicKey);
+        const response = await this.nodeProvider.transactions.postTransactionsBuild(data);
+        return this.convertTransferTxResult(response);
+    }
+    async buildDeployContractTx(params, publicKey) {
+        const data = this.buildDeployContractTxParams(params, publicKey);
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
+        return this.convertDeployContractTxResult(response);
+    }
+    async buildExecuteScriptTx(params, publicKey) {
+        const data = this.buildExecuteScriptTxParams(params, publicKey);
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
+        return this.convertExecuteScriptTxResult(response);
+    }
+    async buildChainedTx(params, publicKeys) {
+        if (params.length !== publicKeys.length) {
+            throw new Error('The number of build chained transaction parameters must match the number of public keys provided');
+        }
+        const data = params.map((param, index) => {
+            const paramType = param.type;
+            switch (paramType) {
+                case 'Transfer': {
+                    const value = this.buildTransferTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                case 'DeployContract': {
+                    const value = this.buildDeployContractTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                case 'ExecuteScript': {
+                    const value = this.buildExecuteScriptTxParams(param, publicKeys[index]);
+                    return { type: paramType, value };
+                }
+                default:
+                    throw new Error(`Unsupported transaction type: ${paramType}`);
+            }
+        });
+        const buildChainedTxsResponse = await this.nodeProvider.transactions.postTransactionsBuildChained(data);
+        const results = buildChainedTxsResponse.map((buildResult) => {
+            const buildResultType = buildResult.type;
+            switch (buildResultType) {
+                case 'Transfer': {
+                    const buildTransferTxResult = buildResult.value;
+                    return {
+                        ...this.convertTransferTxResult(buildTransferTxResult),
+                        type: buildResultType
+                    };
+                }
+                case 'DeployContract': {
+                    const buildDeployContractTxResult = buildResult.value;
+                    return {
+                        ...this.convertDeployContractTxResult(buildDeployContractTxResult),
+                        type: buildResultType
+                    };
+                }
+                case 'ExecuteScript': {
+                    const buildExecuteScriptTxResult = buildResult.value;
+                    return {
+                        ...this.convertExecuteScriptTxResult(buildExecuteScriptTxResult),
+                        type: buildResultType
+                    };
+                }
+                default:
+                    throw new Error(`Unexpected transaction type: ${buildResultType} for ${buildResult.value.txId}`);
+            }
+        });
+        return results;
+    }
+    buildUnsignedTx(params) {
+        const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
+        const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
+        const txId = (0, utils_1.binToHex)((0, hash_1.blakeHash)(unsignedTxBin));
+        const [fromGroup, toGroup] = (0, transaction_1.groupIndexOfTransaction)(decoded);
+        return {
+            fromGroup: fromGroup,
+            toGroup: toGroup,
+            unsignedTx: params.unsignedTx,
+            txId: txId,
+            gasAmount: decoded.gasAmount,
+            gasPrice: decoded.gasPrice
+        };
+    }
+    buildTransferTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { destinations, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             destinations: (0, signer_1.toApiDestinations)(destinations),
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.transactions.postTransactionsBuild(data);
-        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    async buildDeployContractTx(params, publicKey) {
+    buildDeployContractTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(initialAttoAlphAmount),
@@ -65,14 +146,11 @@ class TransactionBuilder {
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
-        const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(response.contractAddress));
-        return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    async buildExecuteScriptTx(params, publicKey) {
+    buildExecuteScriptTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { attoAlphAmount, tokens, gasPrice, ...rest } = params;
-        const data = {
+        return {
             fromPublicKey: publicKey,
             fromPublicKeyType: params.signerKeyType,
             attoAlphAmount: (0, api_1.toApiNumber256Optional)(attoAlphAmount),
@@ -80,21 +158,27 @@ class TransactionBuilder {
             gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
             ...rest
         };
-        const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
-        return { ...response, groupIndex: response.fromGroup, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
-    buildUnsignedTx(params) {
-        const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
-        const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
-        const txId = (0, utils_1.binToHex)((0, hash_1.blakeHash)(unsignedTxBin));
-        const [fromGroup, toGroup] = (0, transaction_1.groupIndexOfTransaction)(decoded);
+    convertTransferTxResult(result) {
         return {
-            fromGroup: fromGroup,
-            toGroup: toGroup,
-            unsignedTx: params.unsignedTx,
-            txId: txId,
-            gasAmount: decoded.gasAmount,
-            gasPrice: decoded.gasPrice
+            ...result,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
+        };
+    }
+    convertDeployContractTxResult(result) {
+        const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.contractAddress));
+        return {
+            ...result,
+            groupIndex: result.fromGroup,
+            contractId,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
+        };
+    }
+    convertExecuteScriptTxResult(result) {
+        return {
+            ...result,
+            groupIndex: result.fromGroup,
+            gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
         };
     }
 }

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

@@ -91,6 +91,26 @@ export interface SignUnsignedTxResult {
     gasAmount: number;
     gasPrice: Number256;
 }
+export type SignTransferChainedTxParams = SignTransferTxParams & {
+    type: 'Transfer';
+};
+export type SignDeployContractChainedTxParams = SignDeployContractTxParams & {
+    type: 'DeployContract';
+};
+export type SignExecuteScriptChainedTxParams = SignExecuteScriptTxParams & {
+    type: 'ExecuteScript';
+};
+export type SignChainedTxParams = SignTransferChainedTxParams | SignDeployContractChainedTxParams | SignExecuteScriptChainedTxParams;
+export type SignTransferChainedTxResult = SignTransferTxResult & {
+    type: 'Transfer';
+};
+export type SignDeployContractChainedTxResult = SignDeployContractTxResult & {
+    type: 'DeployContract';
+};
+export type SignExecuteScriptChainedTxResult = SignExecuteScriptTxResult & {
+    type: 'ExecuteScript';
+};
+export type SignChainedTxResult = SignTransferChainedTxResult | SignDeployContractChainedTxResult | SignExecuteScriptChainedTxResult;
 export type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -33,7 +33,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "3.7.0",
+    "alephium_version": "3.8.1",
     "explorer_backend_version": "2.2.3"
   },
   "type": "commonjs",