@alephium/web3 0.9.0-rc.0 → 0.9.0-rc.1

package/dist/src/signer/index.js

@@ -0,0 +1,36 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./signer"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./tx-builder"), exports);

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

@@ -0,0 +1,60 @@
+import { ExplorerProvider, NodeProvider } from '../api';
+import { node } from '../api';
+import { Account, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, KeyType, MessageHasher } from './types';
+export declare abstract class SignerProvider {
+    abstract get nodeProvider(): NodeProvider | undefined;
+    abstract get explorerProvider(): ExplorerProvider | undefined;
+    protected abstract unsafeGetSelectedAccount(): Promise<Account>;
+    getSelectedAccount(): Promise<Account>;
+    static validateAccount(account: Account): void;
+    abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    abstract signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+}
+export declare abstract class InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase> extends SignerProvider {
+    protected abstract unsafeEnable(opt?: EnableOptions): Promise<Account>;
+    enable(opt?: EnableOptions): Promise<Account>;
+    abstract disconnect(): Promise<void>;
+}
+export declare abstract class SignerProviderSimple extends SignerProvider {
+    abstract get nodeProvider(): NodeProvider;
+    submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult>;
+    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    protected abstract getPublicKey(address: string): Promise<string>;
+    private usePublicKey;
+    signTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
+    buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>>;
+    signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
+    buildDeployContractTx(params: SignDeployContractTxParams): Promise<Omit<SignDeployContractTxResult, 'signature'>>;
+    signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
+    buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>>;
+    signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
+    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+    abstract signRaw(signerAddress: string, hexString: string): Promise<string>;
+}
+export declare abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
+    abstract setSelectedAccount(address: string): Promise<void>;
+    abstract getAccounts(): Promise<Account[]>;
+    getAccount(signerAddress: string): Promise<Account>;
+    getPublicKey(signerAddress: string): Promise<string>;
+}
+export declare abstract class SignerProviderWithCachedAccounts<T extends Account> extends SignerProviderWithMultipleAccounts {
+    private _selectedAccount;
+    protected readonly _accounts: Map<string, T>;
+    protected unsafeGetSelectedAccount(): Promise<T>;
+    setSelectedAccount(address: string): Promise<void>;
+    getAccounts(): Promise<T[]>;
+    getAccount(address: string): Promise<T>;
+}
+export declare function extendMessage(message: string): string;
+export declare function hashMessage(message: string, hasher: MessageHasher): string;
+export declare function verifySignedMessage(message: string, messageHasher: MessageHasher, publicKey: string, signature: string, keyType?: KeyType): boolean;
+export declare function toApiDestination(data: Destination): node.Destination;
+export declare function toApiDestinations(data: Destination[]): node.Destination[];
+export declare function fromApiDestination(data: node.Destination): Destination;

package/dist/src/signer/signer.js

@@ -0,0 +1,236 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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.fromApiDestination = exports.toApiDestinations = exports.toApiDestination = exports.verifySignedMessage = exports.hashMessage = exports.extendMessage = exports.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = exports.InteractiveSignerProvider = exports.SignerProvider = void 0;
+const buffer_1 = require("buffer/");
+const crypto_1 = require("crypto");
+const api_1 = require("../api");
+const utils = __importStar(require("../utils"));
+const blakejs_1 = __importDefault(require("blakejs"));
+const tx_builder_1 = require("./tx-builder");
+const utils_1 = require("../utils");
+class SignerProvider {
+    async getSelectedAccount() {
+        const account = await this.unsafeGetSelectedAccount();
+        SignerProvider.validateAccount(account);
+        return account;
+    }
+    static validateAccount(account) {
+        const derivedAddress = (0, utils_1.addressFromPublicKey)(account.publicKey, account.keyType);
+        const derivedGroup = (0, utils_1.groupOfAddress)(derivedAddress);
+        if (derivedAddress !== account.address || derivedGroup !== account.group) {
+            throw Error(`Invalid accounot data: ${JSON.stringify(account)}`);
+        }
+    }
+}
+exports.SignerProvider = SignerProvider;
+// Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
+class InteractiveSignerProvider extends SignerProvider {
+    async enable(opt) {
+        const account = await this.unsafeEnable(opt);
+        SignerProvider.validateAccount(account);
+        return account;
+    }
+}
+exports.InteractiveSignerProvider = InteractiveSignerProvider;
+class SignerProviderSimple extends SignerProvider {
+    async submitTransaction(params) {
+        const data = { unsignedTx: params.unsignedTx, signature: params.signature };
+        return this.nodeProvider.transactions.postTransactionsSubmit(data);
+    }
+    async signAndSubmitTransferTx(params) {
+        const signResult = await this.signTransferTx(params);
+        await this.submitTransaction(signResult);
+        return signResult;
+    }
+    async signAndSubmitDeployContractTx(params) {
+        const signResult = await this.signDeployContractTx(params);
+        await this.submitTransaction(signResult);
+        return signResult;
+    }
+    async signAndSubmitExecuteScriptTx(params) {
+        const signResult = await this.signExecuteScriptTx(params);
+        await this.submitTransaction(signResult);
+        return signResult;
+    }
+    async signAndSubmitUnsignedTx(params) {
+        const signResult = await this.signUnsignedTx(params);
+        await this.submitTransaction(signResult);
+        return signResult;
+    }
+    async usePublicKey(params) {
+        const { signerAddress, ...restParams } = params;
+        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 { signature, ...response };
+    }
+    async buildTransferTx(params) {
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildTransferTx(params, await this.getPublicKey(params.signerAddress));
+    }
+    async signDeployContractTx(params) {
+        const response = await this.buildDeployContractTx(params);
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { signature, ...response };
+    }
+    async buildDeployContractTx(params) {
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(params, await this.getPublicKey(params.signerAddress));
+    }
+    async signExecuteScriptTx(params) {
+        const response = await this.buildExecuteScriptTx(params);
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { signature, ...response };
+    }
+    async buildExecuteScriptTx(params) {
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).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 response = await tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildUnsignedTx(params);
+        const signature = await this.signRaw(params.signerAddress, response.txId);
+        return { signature, ...response };
+    }
+    async signMessage(params) {
+        const messageHash = hashMessage(params.message, params.messageHasher);
+        const signature = await this.signRaw(params.signerAddress, messageHash);
+        return { signature: signature };
+    }
+}
+exports.SignerProviderSimple = SignerProviderSimple;
+class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
+    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 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();
+    }
+    unsafeGetSelectedAccount() {
+        if (this._selectedAccount === undefined) {
+            throw Error('No account is selected yet');
+        }
+        else {
+            return Promise.resolve(this._selectedAccount);
+        }
+    }
+    setSelectedAccount(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 extendMessage(message) {
+    return 'Alephium Signed Message: ' + message;
+}
+exports.extendMessage = extendMessage;
+function hashMessage(message, hasher) {
+    switch (hasher) {
+        case 'alephium':
+            return utils.binToHex(blakejs_1.default.blake2b(extendMessage(message), undefined, 32));
+        case 'sha256':
+            const sha256 = (0, crypto_1.createHash)('sha256');
+            sha256.update(buffer_1.Buffer.from(message));
+            return utils.binToHex(sha256.digest());
+        case 'blake2b':
+            return utils.binToHex(blakejs_1.default.blake2b(message, undefined, 32));
+        case 'identity':
+            return message;
+        default:
+            throw Error(`Invalid message hasher: ${hasher}`);
+    }
+}
+exports.hashMessage = hashMessage;
+function verifySignedMessage(message, messageHasher, publicKey, signature, keyType) {
+    const messageHash = hashMessage(message, messageHasher);
+    return utils.verifySignature(messageHash, publicKey, signature, keyType);
+}
+exports.verifySignedMessage = verifySignedMessage;
+function toApiDestination(data) {
+    return { ...data, attoAlphAmount: (0, api_1.toApiNumber256)(data.attoAlphAmount), tokens: (0, api_1.toApiTokens)(data.tokens) };
+}
+exports.toApiDestination = toApiDestination;
+function toApiDestinations(data) {
+    return data.map(toApiDestination);
+}
+exports.toApiDestinations = toApiDestinations;
+function fromApiDestination(data) {
+    return { ...data, attoAlphAmount: (0, api_1.fromApiNumber256)(data.attoAlphAmount), tokens: (0, api_1.fromApiTokens)(data.tokens) };
+}
+exports.fromApiDestination = fromApiDestination;

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

@@ -0,0 +1,12 @@
+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 from(nodeProvider: NodeProvider): TransactionBuilder;
+    static from(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): TransactionBuilder;
+    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,96 @@
+"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 from(param0, param1, customFetch) {
+        const nodeProvider = typeof param0 === 'string' ? new api_1.NodeProvider(param0, param1, customFetch) : param0;
+        return new (class extends TransactionBuilder {
+            get nodeProvider() {
+                return nodeProvider;
+            }
+        })();
+    }
+    static validatePublicKey(params, publicKey, keyType) {
+        const address = (0, utils_1.addressFromPublicKey)(publicKey, keyType);
+        if (address !== params.signerAddress) {
+            throw new Error('Unmatched public key');
+        }
+    }
+    async buildTransferTx(params, publicKey) {
+        TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
+        const { destinations, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            fromPublicKeyType: params.signerKeyType,
+            destinations: (0, signer_1.toApiDestinations)(destinations),
+            gasPrice: (0, api_1.toApiNumber256Optional)(gasPrice),
+            ...rest
+        };
+        const response = await this.nodeProvider.transactions.postTransactionsBuild(data);
+        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+    }
+    async buildDeployContractTx(params, publicKey) {
+        TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
+        const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            fromPublicKeyType: params.signerKeyType,
+            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, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+    }
+    async buildExecuteScriptTx(params, publicKey) {
+        TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
+        const { attoAlphAmount, tokens, gasPrice, ...rest } = params;
+        const data = {
+            fromPublicKey: publicKey,
+            fromPublicKeyType: params.signerKeyType,
+            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, groupIndex: response.fromGroup, 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,115 @@
+import { Number256, Token } from '../api';
+import { node } from '../api';
+export type Address = string;
+export type OutputRef = node.OutputRef;
+export interface Destination {
+    address: string;
+    attoAlphAmount: Number256;
+    tokens?: Token[];
+    lockTime?: number;
+    message?: string;
+}
+export type KeyType = 'default' | 'bip340-schnorr';
+export interface Account {
+    keyType: KeyType;
+    address: string;
+    group: number;
+    publicKey: string;
+}
+export type SignerAddress = {
+    signerAddress: string;
+    signerKeyType?: KeyType;
+};
+export interface SignTransferTxParams {
+    signerAddress: string;
+    signerKeyType?: KeyType;
+    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;
+    signerKeyType?: KeyType;
+    bytecode: string;
+    initialAttoAlphAmount?: Number256;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: Number256;
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
+export interface SignDeployContractTxResult {
+    groupIndex: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    contractId: string;
+    contractAddress: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignExecuteScriptTxParams {
+    signerAddress: string;
+    signerKeyType?: KeyType;
+    bytecode: string;
+    attoAlphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+}
+export interface SignExecuteScriptTxResult {
+    groupIndex: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export interface SignUnsignedTxParams {
+    signerAddress: string;
+    signerKeyType?: KeyType;
+    unsignedTx: string;
+}
+export interface SignUnsignedTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    signature: string;
+    gasAmount: number;
+    gasPrice: Number256;
+}
+export type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
+export interface SignMessageParams {
+    signerAddress: string;
+    signerKeyType?: KeyType;
+    message: string;
+    messageHasher: MessageHasher;
+}
+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;
+    keyType?: KeyType;
+    networkId?: string;
+    onDisconnected: () => Promise<void> | void;
+}

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/dist/src/token/index.d.ts

@@ -0,0 +1 @@
+export * from './nft';

package/dist/src/token/index.js

@@ -0,0 +1,34 @@
+"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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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("./nft"), exports);

package/dist/src/token/nft.d.ts

@@ -0,0 +1,10 @@
+export interface NFTMetadata {
+    name: string;
+    description: string;
+    image: string;
+}
+export interface NFTCollectionMetadata {
+    name: string;
+    description: string;
+    image: string;
+}

package/dist/src/token/nft.js

@@ -0,0 +1,19 @@
+"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 });

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

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