@alephium/web3 0.3.0-rc.5 → 0.3.0-rc.7

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

@@ -908,7 +908,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.6.1
+ * @version 1.6.2
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

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

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.6.1
+ * @version 1.6.2
  * @baseUrl ../
  */
 class Api extends HttpClient {

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

@@ -62,6 +62,7 @@ export interface ConfirmedTransaction {
     gasAmount: number;
     /** @format uint256 */
     gasPrice: string;
+    coinbase: boolean;
     type: string;
 }
 export interface ContractOutput {
@@ -77,6 +78,17 @@ export interface ContractOutput {
     spent?: string;
     type: string;
 }
+export interface Event {
+    /** @format block-hash */
+    blockHash: string;
+    /** @format 32-byte-hash */
+    txHash: string;
+    contractAddress: string;
+    inputAddress?: string;
+    /** @format int32 */
+    eventIndex: number;
+    fields?: Val[];
+}
 export interface ExplorerInfo {
     releaseVersion: string;
     commit: string;
@@ -101,6 +113,10 @@ export interface Input {
 export interface InternalServerError {
     detail: string;
 }
+export declare enum IntervalType {
+    Daily = "daily",
+    Hourly = "hourly"
+}
 export interface ListBlocks {
     /** @format int32 */
     total: number;
@@ -196,6 +212,7 @@ export interface Transaction {
     gasAmount: number;
     /** @format uint256 */
     gasPrice: string;
+    coinbase: boolean;
 }
 export declare type TransactionLike = ConfirmedTransaction | UnconfirmedTransaction;
 export interface Unauthorized {
@@ -218,6 +235,35 @@ export interface UnconfirmedTransaction {
     lastSeen: number;
     type: string;
 }
+export declare type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
+export interface ValAddress {
+    /** @format address */
+    value: string;
+    type: string;
+}
+export interface ValArray {
+    value: Val[];
+    type: string;
+}
+export interface ValBool {
+    value: boolean;
+    type: string;
+}
+export interface ValByteVec {
+    /** @format hex-string */
+    value: string;
+    type: string;
+}
+export interface ValI256 {
+    /** @format bigint */
+    value: string;
+    type: string;
+}
+export interface ValU256 {
+    /** @format uint256 */
+    value: string;
+    type: string;
+}
 import 'cross-fetch/polyfill';
 export declare type QueryParamsType = Record<string | number, any>;
 export declare type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
@@ -324,14 +370,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/transactions/{transaction_hash}
          */
         getTransactionsTransactionHash: (transactionHash: string, params?: RequestParams) => Promise<ConfirmedTransaction | UnconfirmedTransaction>;
-        /**
-         * @description Get a transaction from a output reference key
-         *
-         * @tags Transactions
-         * @name GetTransactionsByOutputRefKeyOutputRefKey
-         * @request GET:/transactions/by/output-ref-key/{output_ref_key}
-         */
-        getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey: string, params?: RequestParams) => Promise<Transaction>;
     };
     addresses: {
         /**
@@ -432,6 +470,14 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request GET:/addresses/{address}/tokens/{token_id}/balance
          */
         getAddressesAddressTokensTokenIdBalance: (address: string, tokenId: string, params?: RequestParams) => Promise<AddressBalance>;
+        /**
+         * @description Are the addresses used (at least 1 transaction)
+         *
+         * @tags Addresses, Addresses
+         * @name PostAddressesUsed
+         * @request POST:/addresses/used
+         */
+        postAddressesUsed: (data?: string[], params?: RequestParams) => Promise<boolean[]>;
         /**
          * No description
          *
@@ -444,16 +490,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             toTs: number;
         }, params?: RequestParams) => Promise<string>;
     };
-    addressesActive: {
-        /**
-         * @description Are the addresses active (at least 1 transaction)
-         *
-         * @tags Addresses
-         * @name PostAddressesActive
-         * @request POST:/addresses-active
-         */
-        postAddressesActive: (data?: string[], params?: RequestParams) => Promise<boolean[]>;
-    };
     infos: {
         /**
          * @description Get explorer informations
@@ -584,7 +620,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsHashrates: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<Hashrate[]>;
         /**
          * @description `interval-type` query param: hourly, daily
@@ -597,7 +633,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsTransactionsCount: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<TimedCount[]>;
         /**
          * @description `interval-type` query param: hourly, daily
@@ -610,9 +646,43 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getChartsTransactionsCountPerChain: (query: {
             fromTs: number;
             toTs: number;
-            'interval-type': string;
+            'interval-type': IntervalType;
         }, params?: RequestParams) => Promise<PerChainTimedCount[]>;
     };
+    contractEvents: {
+        /**
+         * @description Get contract events by transaction id
+         *
+         * @tags Contract events
+         * @name GetContractEventsTransactionIdTransactionId
+         * @request GET:/contract-events/transaction-id/{transaction_id}
+         */
+        getContractEventsTransactionIdTransactionId: (transactionId: string, params?: RequestParams) => Promise<Event[]>;
+        /**
+         * @description Get contract events by contract address
+         *
+         * @tags Contract events
+         * @name GetContractEventsContractAddressContractAddress
+         * @request GET:/contract-events/contract-address/{contract_address}
+         */
+        getContractEventsContractAddressContractAddress: (contractAddress: string, query?: {
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Event[]>;
+        /**
+         * @description Get contract events by contract and input addresses
+         *
+         * @tags Contract events
+         * @name GetContractEventsContractAddressContractAddressInputAddressInputAddress
+         * @request GET:/contract-events/contract-address/{contract_address}/input-address/{input_address}
+         */
+        getContractEventsContractAddressContractAddressInputAddressInputAddress: (contractAddress: string, inputAddress: string, query?: {
+            page?: number;
+            limit?: number;
+            reverse?: boolean;
+        }, params?: RequestParams) => Promise<Event[]>;
+    };
     utils: {
         /**
          * @description Perform a sanity check

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

@@ -10,7 +10,12 @@
  * ---------------------------------------------------------------
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Api = exports.HttpClient = exports.ContentType = void 0;
+exports.Api = exports.HttpClient = exports.ContentType = exports.IntervalType = void 0;
+var IntervalType;
+(function (IntervalType) {
+    IntervalType["Daily"] = "daily";
+    IntervalType["Hourly"] = "hourly";
+})(IntervalType = exports.IntervalType || (exports.IntervalType = {}));
 require("cross-fetch/polyfill");
 const utils_1 = require("./utils");
 var ContentType;
@@ -210,19 +215,6 @@ class Api extends HttpClient {
                 method: 'GET',
                 format: 'json',
                 ...params
-            }).then(utils_1.convertHttpResponse),
-            /**
-             * @description Get a transaction from a output reference key
-             *
-             * @tags Transactions
-             * @name GetTransactionsByOutputRefKeyOutputRefKey
-             * @request GET:/transactions/by/output-ref-key/{output_ref_key}
-             */
-            getTransactionsByOutputRefKeyOutputRefKey: (outputRefKey, params = {}) => this.request({
-                path: `/transactions/by/output-ref-key/${outputRefKey}`,
-                method: 'GET',
-                format: 'json',
-                ...params
             }).then(utils_1.convertHttpResponse)
         };
         this.addresses = {
@@ -362,6 +354,21 @@ class Api extends HttpClient {
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Are the addresses used (at least 1 transaction)
+             *
+             * @tags Addresses, Addresses
+             * @name PostAddressesUsed
+             * @request POST:/addresses/used
+             */
+            postAddressesUsed: (data, params = {}) => this.request({
+                path: `/addresses/used`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -376,23 +383,6 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
-        this.addressesActive = {
-            /**
-             * @description Are the addresses active (at least 1 transaction)
-             *
-             * @tags Addresses
-             * @name PostAddressesActive
-             * @request POST:/addresses-active
-             */
-            postAddressesActive: (data, params = {}) => this.request({
-                path: `/addresses-active`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse)
-        };
         this.infos = {
             /**
              * @description Get explorer informations
@@ -601,6 +591,49 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.contractEvents = {
+            /**
+             * @description Get contract events by transaction id
+             *
+             * @tags Contract events
+             * @name GetContractEventsTransactionIdTransactionId
+             * @request GET:/contract-events/transaction-id/{transaction_id}
+             */
+            getContractEventsTransactionIdTransactionId: (transactionId, params = {}) => this.request({
+                path: `/contract-events/transaction-id/${transactionId}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get contract events by contract address
+             *
+             * @tags Contract events
+             * @name GetContractEventsContractAddressContractAddress
+             * @request GET:/contract-events/contract-address/{contract_address}
+             */
+            getContractEventsContractAddressContractAddress: (contractAddress, query, params = {}) => this.request({
+                path: `/contract-events/contract-address/${contractAddress}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * @description Get contract events by contract and input addresses
+             *
+             * @tags Contract events
+             * @name GetContractEventsContractAddressContractAddressInputAddressInputAddress
+             * @request GET:/contract-events/contract-address/{contract_address}/input-address/{input_address}
+             */
+            getContractEventsContractAddressContractAddressInputAddressInputAddress: (contractAddress, inputAddress, query, params = {}) => this.request({
+                path: `/contract-events/contract-address/${contractAddress}/input-address/${inputAddress}`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
         this.utils = {
             /**
              * @description Perform a sanity check

package/dist/src/api/index.d.ts

@@ -27,7 +27,6 @@ export declare class ExplorerProvider {
     readonly blocks: any;
     readonly transactions: any;
     readonly addresses: any;
-    readonly addressesActive: any;
     readonly infos: any;
     readonly unconfirmedTransactions: any;
     readonly tokens: any;

package/dist/src/api/index.js

@@ -119,7 +119,6 @@ class ExplorerProvider {
         this.blocks = api_explorer_1.Api['blocks'];
         this.transactions = api_explorer_1.Api['transactions'];
         this.addresses = api_explorer_1.Api['addresses'];
-        this.addressesActive = api_explorer_1.Api['addressesActive'];
         this.infos = api_explorer_1.Api['infos'];
         this.unconfirmedTransactions = api_explorer_1.Api['unconfirmedTransactions'];
         this.tokens = api_explorer_1.Api['tokens'];
@@ -142,7 +141,6 @@ class ExplorerProvider {
         this.blocks = { ...explorerApi.blocks };
         this.transactions = { ...explorerApi.transactions };
         this.addresses = { ...explorerApi.addresses };
-        this.addressesActive = { ...explorerApi.addressesActive };
         this.infos = { ...explorerApi.infos };
         this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions };
         this.tokens = { ...explorerApi.tokens };

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

@@ -1,2 +1,3 @@
 export * from './signer';
 export * from './types';
+export * from './tx-builder';

package/dist/src/signer/index.js

@@ -33,3 +33,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./signer"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./tx-builder"), exports);

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

@@ -1,6 +1,7 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, Address, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams } from './types';
+import { Account, Address, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, ExtSignTransferTxParams, ExtSignDeployContractTxParams, ExtSignExecuteScriptTxParams, ExtSignUnsignedTxParams, ExtSignMessageParams } from './types';
+import { TransactionBuilder } from './tx-builder';
 export interface SignerProvider {
     get nodeProvider(): NodeProvider | undefined;
     get explorerProvider(): ExplorerProvider | undefined;
@@ -13,15 +14,19 @@ export interface SignerProvider {
     signMessage(params: SignMessageParams): Promise<SignMessageResult>;
 }
 export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase> extends SignerProvider {
-    enable(opt?: EnableOptions): Promise<void>;
+    enable(opt?: EnableOptions): Promise<Address>;
     disconnect(): Promise<void>;
+    signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>;
+    signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>;
 }
-export declare abstract class SignerProviderSimple implements SignerProvider {
-    abstract get nodeProvider(): NodeProvider | undefined;
+export declare abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
     abstract get explorerProvider(): ExplorerProvider | undefined;
     abstract getSelectedAccount(): Promise<Account>;
     getSelectedAddress(): Promise<Address>;
-    private getNodeProvider;
     submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
     signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
     signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
@@ -30,11 +35,11 @@ export declare abstract class SignerProviderSimple implements SignerProvider {
     protected abstract getPublicKey(address: string): Promise<string>;
     private usePublicKey;
     signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult>;
+    buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>>;
     signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult>;
+    buildDeployContractTx(params: SignDeployContractTxParams): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
     signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult>;
+    buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, '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

@@ -48,21 +48,16 @@ const elliptic_1 = require("elliptic");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
 const blakejs_1 = __importDefault(require("blakejs"));
+const tx_builder_1 = require("./tx-builder");
 const ec = new elliptic_1.ec('secp256k1');
-class SignerProviderSimple {
+class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
     async getSelectedAddress() {
         const account = await this.getSelectedAccount();
         return account.address;
     }
-    getNodeProvider() {
-        if (this.nodeProvider === undefined) {
-            throw Error('The signer does not contain a node provider');
-        }
-        return this.nodeProvider;
-    }
     async submitTransaction(params) {
         const data = { unsignedTx: params.unsignedTx, signature: params.signature };
-        return this.getNodeProvider().transactions.postTransactionsSubmit(data);
+        return this.nodeProvider.transactions.postTransactionsSubmit(data);
     }
     async signAndSubmitTransferTx(params) {
         const signResult = await this.signTransferTx(params);
@@ -92,61 +87,33 @@ class SignerProviderSimple {
     async signTransferTx(params) {
         const response = await this.buildTransferTx(params);
         const signature = await this.signRaw(params.signerAddress, response.txId);
-        return { ...response, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { signature, ...response };
     }
     async buildTransferTx(params) {
-        const data = {
-            ...(await this.usePublicKey(params)),
-            destinations: toApiDestinations(params.destinations),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
-        };
-        return this.getNodeProvider().transactions.postTransactionsBuild(data);
+        return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signDeployContractTx(params) {
-        const response = await this.buildContractCreationTx(params);
+        const response = await this.buildDeployContractTx(params);
         const signature = await this.signRaw(params.signerAddress, response.txId);
-        const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress));
-        return { ...response, contractId, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
-    }
-    async buildContractCreationTx(params) {
-        const data = {
-            ...(await this.usePublicKey(params)),
-            initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(params.initialAttoAlphAmount),
-            initialTokenAmounts: (0, api_1.toApiTokens)(params.initialTokenAmounts),
-            issueTokenAmount: (0, api_1.toApiNumber256Optional)(params.issueTokenAmount),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
-        };
-        return this.getNodeProvider().contracts.postContractsUnsignedTxDeployContract(data);
+        return { signature, ...response };
+    }
+    async buildDeployContractTx(params) {
+        return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signExecuteScriptTx(params) {
-        const response = await this.buildScriptTx(params);
+        const response = await this.buildExecuteScriptTx(params);
         const signature = await this.signRaw(params.signerAddress, response.txId);
-        return { ...response, signature, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { signature, ...response };
     }
-    async buildScriptTx(params) {
-        const data = {
-            ...(await this.usePublicKey(params)),
-            attoAlphAmount: (0, api_1.toApiNumber256Optional)(params.attoAlphAmount),
-            tokens: (0, api_1.toApiTokens)(params.tokens),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice)
-        };
-        return this.getNodeProvider().contracts.postContractsUnsignedTxExecuteScript(data);
+    async buildExecuteScriptTx(params) {
+        return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress));
     }
     // in general, wallet should show the decoded information to user for confirmation
     // please overwrite this function for real wallet
     async signUnsignedTx(params) {
-        const data = { unsignedTx: params.unsignedTx };
-        const decoded = await this.getNodeProvider().transactions.postTransactionsDecodeUnsignedTx(data);
-        const signature = await this.signRaw(params.signerAddress, decoded.unsignedTx.txId);
-        return {
-            fromGroup: decoded.fromGroup,
-            toGroup: decoded.toGroup,
-            unsignedTx: params.unsignedTx,
-            txId: decoded.unsignedTx.txId,
-            signature,
-            gasAmount: decoded.unsignedTx.gasAmount,
-            gasPrice: (0, api_1.fromApiNumber256)(decoded.unsignedTx.gasPrice)
-        };
+        const response = await this.buildUnsignedTx(params);
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { signature, ...response };
     }
     async signMessage(params) {
         const extendedMessage = extendMessage(params.message);

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

@@ -0,0 +1,17 @@
+import { NodeProvider } from '../api';
+import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult } from './types';
+export declare abstract class TransactionBuilder {
+    abstract get nodeProvider(): NodeProvider;
+    static create(baseUrl: string, apiKey?: string): {
+        readonly nodeProvider: NodeProvider;
+        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">>;
+        buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, "signature">>;
+    };
+    private static validatePublicKey;
+    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'>>;
+    buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, 'signature'>>;
+}

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

@@ -0,0 +1,93 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionBuilder = void 0;
+const __1 = require("..");
+const api_1 = require("../api");
+const utils_1 = require("../utils");
+const signer_1 = require("./signer");
+class TransactionBuilder {
+    static create(baseUrl, apiKey) {
+        const nodeProvider = new api_1.NodeProvider(baseUrl, apiKey);
+        return new (class extends TransactionBuilder {
+            get nodeProvider() {
+                return nodeProvider;
+            }
+        })();
+    }
+    static validatePublicKey(params, publicKey) {
+        const address = (0, utils_1.addressFromPublicKey)(publicKey);
+        if (address !== params.signerAddress) {
+            throw new Error('Unmatched public key');
+        }
+    }
+    async buildTransferTx(params, publicKey) {
+        TransactionBuilder.validatePublicKey(params, publicKey);
+        const { destinations, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            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) {
+        TransactionBuilder.validatePublicKey(params, publicKey);
+        const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(initialAttoAlphAmount),
+            initialTokenAmounts: (0, api_1.toApiTokens)(initialTokenAmounts),
+            issueTokenAmount: (0, api_1.toApiNumber256Optional)(issueTokenAmount),
+            gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
+            ...rest
+        };
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
+        const contractId = __1.utils.binToHex(__1.utils.contractIdFromAddress(response.contractAddress));
+        return { ...response, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+    }
+    async buildExecuteScriptTx(params, publicKey) {
+        TransactionBuilder.validatePublicKey(params, publicKey);
+        const { attoAlphAmount, tokens, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            attoAlphAmount: (0, api_1.toApiNumber256Optional)(attoAlphAmount),
+            tokens: (0, api_1.toApiTokens)(tokens),
+            gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
+            ...rest
+        };
+        const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
+        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+    }
+    async buildUnsignedTx(params) {
+        const data = { unsignedTx: params.unsignedTx };
+        const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data);
+        return {
+            fromGroup: decoded.fromGroup,
+            toGroup: decoded.toGroup,
+            unsignedTx: params.unsignedTx,
+            txId: decoded.unsignedTx.txId,
+            gasAmount: decoded.unsignedTx.gasAmount,
+            gasPrice: (0, api_1.fromApiNumber256)(decoded.unsignedTx.gasPrice)
+        };
+    }
+}
+exports.TransactionBuilder = TransactionBuilder;

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

@@ -101,9 +101,21 @@ export interface SubmissionResult {
 }
 export interface EnableOptionsBase {
     chainGroup?: number;
+    networkId: string;
     onDisconnected: () => Promise<void>;
-    onNetworkChanged: (network: {
-        networkName: string;
-        networkId: number;
-    }) => Promise<void>;
 }
+export declare type ExtSignTransferTxParams = SignTransferTxParams & {
+    networkId: string;
+};
+export declare type ExtSignDeployContractTxParams = SignDeployContractTxParams & {
+    networkId: string;
+};
+export declare type ExtSignExecuteScriptTxParams = SignExecuteScriptTxParams & {
+    networkId: string;
+};
+export declare type ExtSignUnsignedTxParams = SignUnsignedTxParams & {
+    networkId: string;
+};
+export declare type ExtSignMessageParams = SignMessageParams & {
+    networkId: string;
+};