@alephium/web3 0.0.1-test.0

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;
+    initialAttoAlphAmount?: 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;
+    attoAlphAmount?: 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/src/transaction/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sign-verify';
+export * from './status';

package/dist/src/transaction/index.js

@@ -0,0 +1,31 @@
+"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("./sign-verify"), exports);
+__exportStar(require("./status"), exports);

package/dist/src/transaction/sign-verify.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/transaction/sign-verify.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;

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

@@ -0,0 +1,10 @@
+import { TxStatus } from '../api/api-alephium';
+import { Subscription, SubscribeOptions } from '../utils';
+export declare class TxStatusSubscription extends Subscription<TxStatus> {
+    readonly txId: string;
+    readonly fromGroup?: number;
+    readonly toGroup?: number;
+    constructor(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number);
+    polling(): Promise<void>;
+}
+export declare function subscribeToTxStatus(options: SubscribeOptions<TxStatus>, txId: string, fromGroup?: number, toGroup?: number): TxStatusSubscription;

package/dist/src/transaction/status.js

@@ -0,0 +1,48 @@
+"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.subscribeToTxStatus = exports.TxStatusSubscription = void 0;
+const utils_1 = require("../utils");
+class TxStatusSubscription extends utils_1.Subscription {
+    constructor(options, txId, fromGroup, toGroup) {
+        super(options);
+        this.txId = txId;
+        this.fromGroup = fromGroup;
+        this.toGroup = toGroup;
+        this.startPolling();
+    }
+    async polling() {
+        try {
+            const txStatus = await this.provider.transactions.getTransactionsStatus({
+                txId: this.txId,
+                fromGroup: this.fromGroup,
+                toGroup: this.toGroup
+            });
+            await this.messageCallback(txStatus);
+        }
+        catch (err) {
+            await this.errorCallback(err, this);
+        }
+    }
+}
+exports.TxStatusSubscription = TxStatusSubscription;
+function subscribeToTxStatus(options, txId, fromGroup, toGroup) {
+    return new TxStatusSubscription(options, txId, fromGroup, toGroup);
+}
+exports.subscribeToTxStatus = subscribeToTxStatus;

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

@@ -0,0 +1 @@
+export declare function addressToGroup(address: string, totalNumberOfGroups: number): number;

package/dist/src/utils/address.js

@@ -0,0 +1,42 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToGroup = void 0;
+const bs58_1 = __importDefault(require("./bs58"));
+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;
+    const hash = toPosInt(xorByte(value));
+    const group = hash % totalNumberOfGroups;
+    return group;
+}
+exports.addressToGroup = addressToGroup;
+function xorByte(value) {
+    const byte0 = value >> 24;
+    const byte1 = value >> 16;
+    const byte2 = value >> 8;
+    return byte0 ^ byte1 ^ byte2 ^ value;
+}
+function toPosInt(byte) {
+    return byte & 0xff;
+}

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

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