@alephium/web3 0.0.3 → 0.1.0-rc.2

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

@@ -0,0 +1,143 @@
+import { NodeProvider } from '../api';
+import { node } from '../api';
+import { Token } from '../api/api-alephium';
+export interface SignResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+}
+export interface Account {
+    address: string;
+    group: number;
+    publicKey: string;
+}
+export declare type SubmitTx = {
+    submitTx?: boolean;
+};
+export declare type SignerAddress = {
+    signerAddress: string;
+};
+export declare type GetAccountsParams = undefined;
+export declare type GetAccountsResult = Account[];
+export interface SignTransferTxParams {
+    signerAddress: string;
+    destinations: node.Destination[];
+    utxos?: node.OutputRef[];
+    gasAmount?: number;
+    gasPrice?: string;
+    submitTx?: boolean;
+}
+export interface SignTransferTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+}
+export interface SignDeployContractTxParams {
+    signerAddress: string;
+    bytecode: string;
+    initialAlphAmount?: string;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: string;
+    gasAmount?: number;
+    gasPrice?: string;
+    submitTx?: boolean;
+}
+export interface SignDeployContractTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    contractId: string;
+    contractAddress: string;
+}
+export interface SignExecuteScriptTxParams {
+    signerAddress: string;
+    bytecode: string;
+    alphAmount?: string;
+    tokens?: node.Token[];
+    gasAmount?: number;
+    gasPrice?: string;
+    submitTx?: boolean;
+}
+export interface SignExecuteScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+}
+export interface SignUnsignedTxParams {
+    signerAddress: string;
+    unsignedTx: string;
+    submitTx?: boolean;
+}
+export interface SignUnsignedTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+}
+export interface SignHexStringParams {
+    signerAddress: string;
+    hexString: string;
+}
+export interface SignHexStringResult {
+    signature: string;
+}
+export interface SignMessageParams {
+    signerAddress: string;
+    message: string;
+}
+export interface SignMessageResult {
+    signature: string;
+}
+export interface SignerProvider {
+    getAccounts(): Promise<Account[]>;
+    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signHexString(params: SignHexStringParams): Promise<SignHexStringResult>;
+    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+}
+export declare abstract class SignerWithNodeProvider implements SignerProvider {
+    readonly provider: NodeProvider;
+    alwaysSubmitTx: boolean;
+    abstract getAccounts(): Promise<Account[]>;
+    getAccount(signerAddress: string): Promise<Account>;
+    constructor(provider: NodeProvider, alwaysSubmitTx: boolean);
+    private defaultSignerAddress;
+    submitTransaction(unsignedTx: string, txHash: string, signerAddress?: string): Promise<SubmissionResult>;
+    private shouldSubmitTx;
+    private usePublicKey;
+    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    buildTransferTx(params: SignTransferTxParams): Promise<node.BuildTransactionResult>;
+    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    buildContractCreationTx(params: SignDeployContractTxParams): Promise<node.BuildDeployContractTxResult>;
+    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    buildScriptTx(params: SignExecuteScriptTxParams): Promise<node.BuildExecuteScriptTxResult>;
+    signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    protected handleSign(response: {
+        fromGroup: number;
+        toGroup: number;
+        signerAddress: string;
+        unsignedTx: string;
+        txId: string;
+    }, submitTx: boolean): Promise<SignResult>;
+    signHexString(params: SignHexStringParams): Promise<SignHexStringResult>;
+    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+    abstract signRaw(signerAddress: string, hexString: string): Promise<string>;
+}
+export interface SubmissionResult {
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export declare function verifyHexString(hexString: string, publicKey: string, signature: string): boolean;
+export declare function verifySignedMessage(message: string, publicKey: string, signature: string): boolean;

package/dist/src/signer/signer.js

@@ -0,0 +1,184 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignedMessage = exports.verifyHexString = exports.SignerWithNodeProvider = void 0;
+const elliptic_1 = require("elliptic");
+const utils = __importStar(require("../utils"));
+const utils_1 = require("../utils");
+const blakejs_1 = __importDefault(require("blakejs"));
+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)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+(0, utils_1.assertType)();
+class SignerWithNodeProvider {
+    constructor(provider, alwaysSubmitTx) {
+        this.provider = provider;
+        this.alwaysSubmitTx = alwaysSubmitTx;
+    }
+    async getAccount(signerAddress) {
+        const accounts = await this.getAccounts();
+        const account = accounts.find((a) => a.address === signerAddress);
+        if (typeof account === 'undefined') {
+            throw new Error('Unmatched signerAddress');
+        }
+        else {
+            return account;
+        }
+    }
+    async defaultSignerAddress() {
+        return (await this.getAccounts())[0].address;
+    }
+    async submitTransaction(unsignedTx, txHash, signerAddress) {
+        const address = typeof signerAddress !== 'undefined' ? signerAddress : await this.defaultSignerAddress();
+        const signature = await this.signRaw(address, txHash);
+        const params = { unsignedTx: unsignedTx, signature: signature };
+        return this.provider.transactions.postTransactionsSubmit(params);
+    }
+    shouldSubmitTx(params) {
+        return this.alwaysSubmitTx || (params.submitTx ? params.submitTx : true);
+    }
+    async usePublicKey(params) {
+        const { signerAddress, ...restParams } = params;
+        const allAccounts = await this.getAccounts();
+        const signerAccount = allAccounts.find((account) => account.address === signerAddress);
+        if (typeof signerAccount === 'undefined') {
+            throw new Error('Unknown signer address');
+        }
+        else {
+            return { fromPublicKey: signerAccount.publicKey, ...restParams };
+        }
+    }
+    async signTransferTx(params) {
+        const response = await this.buildTransferTx(params);
+        return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+    }
+    async buildTransferTx(params) {
+        return this.provider.transactions.postTransactionsBuild(await this.usePublicKey(params));
+    }
+    async signDeployContractTx(params) {
+        const response = await this.buildContractCreationTx(params);
+        const result = await this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+        const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress));
+        return { ...result, contractId: contractId, contractAddress: response.contractAddress };
+    }
+    async buildContractCreationTx(params) {
+        return this.provider.contracts.postContractsUnsignedTxDeployContract(await this.usePublicKey(params));
+    }
+    async signExecuteScriptTx(params) {
+        const response = await this.buildScriptTx(params);
+        return this.handleSign({ signerAddress: params.signerAddress, ...response }, this.shouldSubmitTx(params));
+    }
+    async buildScriptTx(params) {
+        return this.provider.contracts.postContractsUnsignedTxExecuteScript(await this.usePublicKey(params));
+    }
+    // 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.provider.transactions.postTransactionsDecodeUnsignedTx(data);
+        return this.handleSign({
+            fromGroup: decoded.fromGroup,
+            toGroup: decoded.toGroup,
+            signerAddress: params.signerAddress,
+            unsignedTx: params.unsignedTx,
+            txId: decoded.unsignedTx.txId
+        }, params.submitTx ? params.submitTx : true // we don't consider `alwaysSubmitTx` as the tx might needs multiple signatures
+        );
+    }
+    async handleSign(response, submitTx) {
+        // sign the tx
+        const signature = await this.signRaw(response.signerAddress, response.txId);
+        // submit the tx if required
+        if (submitTx) {
+            await this.provider.transactions.postTransactionsSubmit({
+                unsignedTx: response.unsignedTx,
+                signature: signature
+            });
+        }
+        // return the signature back to the provider
+        return {
+            fromGroup: response.fromGroup,
+            toGroup: response.toGroup,
+            unsignedTx: response.unsignedTx,
+            txId: response.txId,
+            signature: signature
+        };
+    }
+    async signHexString(params) {
+        const signature = await this.signRaw(params.signerAddress, params.hexString);
+        return { signature: signature };
+    }
+    async signMessage(params) {
+        const extendedMessage = extendMessage(params.message);
+        const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
+        const signature = await this.signRaw(params.signerAddress, utils.binToHex(messageHash));
+        return { signature: signature };
+    }
+}
+exports.SignerWithNodeProvider = SignerWithNodeProvider;
+function verifyHexString(hexString, publicKey, signature) {
+    try {
+        const key = ec.keyFromPublic(publicKey, 'hex');
+        return key.verify(hexString, utils.signatureDecode(ec, signature));
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.verifyHexString = verifyHexString;
+function extendMessage(message) {
+    return 'Alephium Signed Message: ' + message;
+}
+function verifySignedMessage(message, publicKey, signature) {
+    const extendedMessage = extendMessage(message);
+    const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
+    return verifyHexString(utils.binToHex(messageHash), publicKey, signature);
+}
+exports.verifySignedMessage = verifySignedMessage;

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

@@ -0,0 +1,7 @@
+import { NodeProvider } from '../api';
+import { NodeWallet } from '../signer';
+export declare const testWalletName = "alephium-web3-test-only-wallet";
+export declare const testAddress = "1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH";
+export declare const testPassword = "alph";
+export declare function testWallet(provider: NodeProvider): Promise<NodeWallet>;
+export * from './privatekey-wallet';

package/dist/src/test/index.js

@@ -0,0 +1,41 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testWallet = exports.testPassword = exports.testAddress = exports.testWalletName = void 0;
+const signer_1 = require("../signer");
+exports.testWalletName = 'alephium-web3-test-only-wallet';
+exports.testAddress = '1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH';
+exports.testPassword = 'alph';
+async function testWallet(provider) {
+    const wallet = new signer_1.NodeWallet(provider, exports.testWalletName);
+    await wallet.unlock(exports.testPassword);
+    return wallet;
+}
+exports.testWallet = testWallet;
+__exportStar(require("./privatekey-wallet"), exports);

package/dist/src/test/privatekey-wallet.d.ts

@@ -0,0 +1,12 @@
+import { NodeProvider } from '../api';
+import { Account, SignerWithNodeProvider } from '../signer';
+export declare class PrivateKeyWallet extends SignerWithNodeProvider {
+    readonly privateKey: string;
+    readonly publicKey: string;
+    readonly address: string;
+    readonly group: number;
+    constructor(provider: NodeProvider, privateKey: string, alwaysSubmitTx?: boolean);
+    static Random(provider: NodeProvider, alwaysSubmitTx?: boolean): PrivateKeyWallet;
+    getAccounts(): Promise<Account[]>;
+    signRaw(signerAddress: string, hexString: string): Promise<string>;
+}

package/dist/src/test/privatekey-wallet.js

@@ -0,0 +1,68 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrivateKeyWallet = void 0;
+const elliptic_1 = require("elliptic");
+const signer_1 = require("../signer");
+const utils = __importStar(require("../utils"));
+const ec = new elliptic_1.ec('secp256k1');
+class PrivateKeyWallet extends signer_1.SignerWithNodeProvider {
+    constructor(provider, privateKey, alwaysSubmitTx = true) {
+        super(provider, alwaysSubmitTx);
+        this.privateKey = privateKey;
+        this.publicKey = utils.publicKeyFromPrivateKey(privateKey);
+        this.address = utils.addressFromPublicKey(this.publicKey);
+        this.group = utils.groupOfAddress(this.address);
+    }
+    static Random(provider, alwaysSubmitTx = true) {
+        const keyPair = ec.genKeyPair();
+        return new PrivateKeyWallet(provider, keyPair.getPrivate().toString('hex'), alwaysSubmitTx);
+    }
+    async getAccounts() {
+        return [{ address: this.address, publicKey: this.publicKey, group: this.group }];
+    }
+    async signRaw(signerAddress, hexString) {
+        if (signerAddress !== this.address) {
+            throw Error('Unmatched signer address');
+        }
+        const key = ec.keyFromPrivate(this.privateKey);
+        const signature = key.sign(hexString);
+        return utils.signatureEncode(signature);
+    }
+}
+exports.PrivateKeyWallet = PrivateKeyWallet;

package/dist/{lib → src/utils}/address.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addressToGroup = void 0;
 const bs58_1 = __importDefault(require("./bs58"));
-const djb2_1 = __importDefault(require("../lib/djb2"));
+const djb2_1 = __importDefault(require("./djb2"));
 function addressToGroup(address, totalNumberOfGroups) {
     const bytes = bs58_1.default.decode(address).slice(1);
     const value = (0, djb2_1.default)(bytes) | 1;

package/dist/{lib → src/utils}/bs58.d.ts

@@ -1,4 +1,4 @@
 /** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
 import basex from 'base-x';
-declare const _default: basex.BaseConverter;
-export default _default;
+export declare const bs58: basex.BaseConverter;
+export default bs58;

package/dist/{lib → src/utils}/bs58.js

@@ -20,7 +20,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.bs58 = void 0;
 /** This source is under MIT License and come originally from https://github.com/cryptocoinjs/bs58 **/
 const base_x_1 = __importDefault(require("base-x"));
 const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-exports.default = (0, base_x_1.default)(ALPHABET);
+exports.bs58 = (0, base_x_1.default)(ALPHABET);
+exports.default = exports.bs58;

package/dist/{lib → src/utils}/djb2.js

@@ -20,7 +20,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function djb2(bytes) {
     let hash = 5381;
     for (let i = 0; i < bytes.length; i++) {
-        hash = (hash << 5) + hash + (bytes[i] & 0xff);
+        hash = (hash << 5) + hash + (bytes[`${i}`] & 0xff);
     }
     return hash;
 }

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

@@ -0,0 +1,6 @@
+export * from './address';
+export * from './bs58';
+export * from './djb2';
+export * from './password-crypto';
+export * from './transaction';
+export * from './utils';

package/dist/src/utils/index.js

@@ -0,0 +1,35 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./address"), exports);
+__exportStar(require("./bs58"), exports);
+__exportStar(require("./djb2"), exports);
+__exportStar(require("./password-crypto"), exports);
+__exportStar(require("./transaction"), exports);
+__exportStar(require("./utils"), exports);

package/dist/{lib → src/utils}/password-crypto.js

@@ -18,22 +18,23 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.decrypt = exports.encrypt = void 0;
+const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const saltByteLength = 64;
 const ivByteLength = 64;
 const authTagLength = 16;
 const encrypt = (password, dataRaw) => {
-    const data = Buffer.from(dataRaw, 'utf8');
+    const data = buffer_1.Buffer.from(dataRaw, 'utf8');
     const salt = (0, crypto_1.randomBytes)(saltByteLength);
     const derivedKey = keyFromPassword(password, salt);
     const iv = (0, crypto_1.randomBytes)(ivByteLength);
     const cipher = createCipher(derivedKey, iv);
-    const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+    const encrypted = buffer_1.Buffer.concat([cipher.update(data), cipher.final()]);
     const authTag = cipher.getAuthTag();
     const payload = {
         salt: salt.toString('hex'),
         iv: iv.toString('hex'),
-        encrypted: Buffer.concat([encrypted, authTag]).toString('hex'),
+        encrypted: buffer_1.Buffer.concat([encrypted, authTag]).toString('hex'),
         version: 1
     };
     return JSON.stringify(payload);
@@ -45,15 +46,15 @@ const decrypt = (password, payloadRaw) => {
     if (version !== 1) {
         throw new Error(`Invalid version: got ${version}, expected: 1`);
     }
-    const salt = Buffer.from(payload.salt, 'hex');
-    const iv = Buffer.from(payload.iv, 'hex');
-    const encrypted = Buffer.from(payload.encrypted, 'hex');
+    const salt = buffer_1.Buffer.from(payload.salt, 'hex');
+    const iv = buffer_1.Buffer.from(payload.iv, 'hex');
+    const encrypted = buffer_1.Buffer.from(payload.encrypted, 'hex');
     const derivedKey = keyFromPassword(password, salt);
     const decipher = createDecipher(derivedKey, iv);
     const data = encrypted.slice(0, encrypted.length - authTagLength);
     const authTag = encrypted.slice(encrypted.length - authTagLength, encrypted.length);
     decipher.setAuthTag(authTag);
-    const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+    const decrypted = buffer_1.Buffer.concat([decipher.update(data), decipher.final()]);
     return decrypted.toString('utf8');
 };
 exports.decrypt = decrypt;

package/dist/src/utils/transaction.d.ts

@@ -0,0 +1,2 @@
+export declare function transactionSign(txHash: string, privateKey: string): string;
+export declare function transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean;

package/dist/src/utils/transaction.js

@@ -0,0 +1,58 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionVerifySignature = exports.transactionSign = void 0;
+const elliptic_1 = require("elliptic");
+const utils = __importStar(require("./utils"));
+const ec = new elliptic_1.ec('secp256k1');
+function transactionSign(txHash, privateKey) {
+    const keyPair = ec.keyFromPrivate(privateKey);
+    const signature = keyPair.sign(txHash);
+    return utils.signatureEncode(signature);
+}
+exports.transactionSign = transactionSign;
+function transactionVerifySignature(txHash, publicKey, signature) {
+    try {
+        const key = ec.keyFromPublic(publicKey, 'hex');
+        return key.verify(txHash, utils.signatureDecode(ec, signature));
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.transactionVerifySignature = transactionVerifySignature;