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

package/dist/src/signer/signer.js

@@ -43,32 +43,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.verifyHexString = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = void 0;
+exports.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.verifyHexString = exports.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = void 0;
 const elliptic_1 = require("elliptic");
 const api_1 = require("../api");
 const utils = __importStar(require("../utils"));
-const utils_1 = require("../utils");
 const blakejs_1 = __importDefault(require("blakejs"));
+const tx_builder_1 = require("./tx-builder");
 const ec = new elliptic_1.ec('secp256k1');
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-utils_1.assertType;
-(0, utils_1.assertType)();
-class SignerProviderSimple {
-    getNodeProvider() {
-        if (this.nodeProvider === undefined) {
-            throw Error('The signer does not contain a node provider');
-        }
-        return this.nodeProvider;
+class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
+    async getSelectedAddress() {
+        const account = await this.getSelectedAccount();
+        return account.address;
     }
     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,72 +81,39 @@ class SignerProviderSimple {
     }
     async usePublicKey(params) {
         const { signerAddress, ...restParams } = params;
-        const selectedAccount = await this.getSelectedAccount();
-        if (signerAddress !== selectedAccount.address) {
-            throw new Error('The signer address is not the selected address');
-        }
-        else {
-            return { fromPublicKey: selectedAccount.publicKey, ...restParams };
-        }
+        const publicKey = await this.getPublicKey(signerAddress);
+        return { fromPublicKey: publicKey, ...restParams };
     }
     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);
@@ -178,8 +134,48 @@ class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
             return account;
         }
     }
+    async getPublicKey(signerAddress) {
+        const account = await this.getAccount(signerAddress);
+        return account.publicKey;
+    }
 }
 exports.SignerProviderWithMultipleAccounts = SignerProviderWithMultipleAccounts;
+class SignerProviderWithCachedAccounts extends SignerProviderWithMultipleAccounts {
+    constructor() {
+        super(...arguments);
+        this._selectedAccount = undefined;
+        this._accounts = new Map();
+    }
+    getSelectedAccount() {
+        if (this._selectedAccount === undefined) {
+            throw Error('No account is selected yet');
+        }
+        else {
+            return Promise.resolve(this._selectedAccount);
+        }
+    }
+    setSelectedAddress(address) {
+        const accountOpt = this._accounts.get(address);
+        if (accountOpt === undefined) {
+            throw Error('The address is not in the accounts');
+        }
+        else {
+            this._selectedAccount = accountOpt;
+            return Promise.resolve();
+        }
+    }
+    getAccounts() {
+        return Promise.resolve(Array.from(this._accounts.values()));
+    }
+    async getAccount(address) {
+        const account = this._accounts.get(address);
+        if (account === undefined) {
+            throw Error('The address is not in the accounts');
+        }
+        return Promise.resolve(account);
+    }
+}
+exports.SignerProviderWithCachedAccounts = SignerProviderWithCachedAccounts;
 function verifyHexString(hexString, publicKey, signature) {
     try {
         const key = ec.keyFromPublic(publicKey, 'hex');
@@ -199,7 +195,6 @@ function verifySignedMessage(message, publicKey, signature) {
     return verifyHexString(utils.binToHex(messageHash), publicKey, signature);
 }
 exports.verifySignedMessage = verifySignedMessage;
-utils_1.assertType;
 function toApiDestination(data) {
     return { ...data, attoAlphAmount: (0, api_1.toApiNumber256)(data.attoAlphAmount), tokens: (0, api_1.toApiTokens)(data.tokens) };
 }

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

@@ -0,0 +1,121 @@
+import { Number256, Token } from '../api';
+import { node } from '../api';
+export declare type Address = string;
+export declare type OutputRef = node.OutputRef;
+export interface Destination {
+    address: string;
+    attoAlphAmount: Number256;
+    tokens?: Token[];
+    lockTime?: number;
+    message?: string;
+}
+export interface Account {
+    address: string;
+    group: number;
+    publicKey: string;
+}
+export declare type SignerAddress = {
+    signerAddress: string;
+};
+export interface SignTransferTxParams {
+    signerAddress: string;
+    destinations: Destination[];
+    utxos?: OutputRef[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
+export interface SignTransferTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignDeployContractTxParams {
+    signerAddress: string;
+    bytecode: string;
+    initialAttoAlphAmount?: Number256;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: Number256;
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
+export interface SignDeployContractTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    contractId: string;
+    contractAddress: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignExecuteScriptTxParams {
+    signerAddress: string;
+    bytecode: string;
+    attoAlphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
+export interface SignExecuteScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignUnsignedTxParams {
+    signerAddress: string;
+    unsignedTx: string;
+}
+export interface SignUnsignedTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignMessageParams {
+    signerAddress: string;
+    message: string;
+}
+export interface SignMessageResult {
+    signature: string;
+}
+export interface SubmitTransactionParams {
+    unsignedTx: string;
+    signature: string;
+}
+export interface SubmissionResult {
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export interface EnableOptionsBase {
+    chainGroup?: number;
+    networkId: string;
+    onDisconnected: () => 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;
+};

package/dist/src/signer/types.js

@@ -0,0 +1,30 @@
+"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 });
+const utils_1 = require("../utils");
+utils_1.assertType;
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+utils_1.assertType;
+(0, utils_1.assertType)();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.3.0-rc.4",
+  "version": "0.3.0-rc.7",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,8 +27,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.6.0-rc5",
-    "explorer_backend_version": "1.11.2"
+    "alephium_version": "1.6.2",
+    "explorer_backend_version": "1.12.0-rc2"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
@@ -71,6 +71,7 @@
     "jest-websocket-mock": "^2.2.1",
     "mock-fs": "^5.1.2",
     "mock-socket": "^9.0.8",
+    "path-browserify": "^1.0.1",
     "prettier": "^2.3.2",
     "process": "^0.11.10",
     "rewire": "^6.0.0",

package/src/api/api-alephium.ts

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