@alephium/web3 0.5.0-rc.2 → 0.5.0-rc.21

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

@@ -1,32 +1,26 @@
 import { ExplorerProvider, NodeProvider } from '../api';
 import { node } from '../api';
-import { Account, Address, EnableOptionsBase, Destination, SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignExecuteScriptTxResult, SignMessageParams, SignMessageResult, SignTransferTxParams, SignTransferTxResult, SignUnsignedTxParams, SignUnsignedTxResult, SubmissionResult, SubmitTransactionParams, ExtSignTransferTxParams, ExtSignDeployContractTxParams, ExtSignExecuteScriptTxParams, ExtSignUnsignedTxParams, ExtSignMessageParams } from './types';
-import { TransactionBuilder } from './tx-builder';
-export interface SignerProvider {
-    get nodeProvider(): NodeProvider | undefined;
-    get explorerProvider(): ExplorerProvider | undefined;
-    getSelectedAddress(): Promise<Address>;
-    signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>;
-    signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    signMessage(params: SignMessageParams): Promise<SignMessageResult>;
+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 interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase> extends SignerProvider {
-    enable(opt?: EnableOptions): Promise<Address>;
-    disconnect(): Promise<void>;
-    signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>;
-    signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>;
+export declare abstract class 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 TransactionBuilder implements SignerProvider {
-    abstract get explorerProvider(): ExplorerProvider | undefined;
-    abstract getSelectedAccount(): Promise<Account>;
-    getSelectedAddress(): Promise<Address>;
+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>;
@@ -45,7 +39,7 @@ export declare abstract class SignerProviderSimple extends TransactionBuilder im
     abstract signRaw(signerAddress: string, hexString: string): Promise<string>;
 }
 export declare abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
-    abstract setSelectedAddress(address: string): Promise<void>;
+    abstract setSelectedAccount(address: string): Promise<void>;
     abstract getAccounts(): Promise<Account[]>;
     getAccount(signerAddress: string): Promise<Account>;
     getPublicKey(signerAddress: string): Promise<string>;
@@ -53,13 +47,14 @@ export declare abstract class SignerProviderWithMultipleAccounts extends SignerP
 export declare abstract class SignerProviderWithCachedAccounts<T extends Account> extends SignerProviderWithMultipleAccounts {
     private _selectedAccount;
     protected readonly _accounts: Map<string, T>;
-    getSelectedAccount(): Promise<T>;
-    setSelectedAddress(address: string): Promise<void>;
+    protected unsafeGetSelectedAccount(): Promise<T>;
+    setSelectedAccount(address: string): Promise<void>;
     getAccounts(): Promise<T[]>;
     getAccount(address: string): Promise<T>;
 }
-export declare function verifyHexString(hexString: string, publicKey: string, signature: string): boolean;
-export declare function verifySignedMessage(message: string, publicKey: string, signature: string): boolean;
+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

@@ -43,18 +43,39 @@ 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.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = void 0;
-const elliptic_1 = require("elliptic");
+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 ec = new elliptic_1.ec('secp256k1');
-class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
-    async getSelectedAddress() {
-        const account = await this.getSelectedAccount();
-        return account.address;
+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);
@@ -90,7 +111,7 @@ class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
         return { signature, ...response };
     }
     async buildTransferTx(params) {
-        return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress));
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildTransferTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signDeployContractTx(params) {
         const response = await this.buildDeployContractTx(params);
@@ -98,7 +119,7 @@ class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
         return { signature, ...response };
     }
     async buildDeployContractTx(params) {
-        return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress));
+        return tx_builder_1.TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(params, await this.getPublicKey(params.signerAddress));
     }
     async signExecuteScriptTx(params) {
         const response = await this.buildExecuteScriptTx(params);
@@ -106,19 +127,18 @@ class SignerProviderSimple extends tx_builder_1.TransactionBuilder {
         return { signature, ...response };
     }
     async buildExecuteScriptTx(params) {
-        return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress));
+        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 this.buildUnsignedTx(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 extendedMessage = extendMessage(params.message);
-        const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
-        const signature = await this.signRaw(params.signerAddress, utils.binToHex(messageHash));
+        const messageHash = hashMessage(params.message, params.messageHasher);
+        const signature = await this.signRaw(params.signerAddress, messageHash);
         return { signature: signature };
     }
 }
@@ -146,7 +166,7 @@ class SignerProviderWithCachedAccounts extends SignerProviderWithMultipleAccount
         this._selectedAccount = undefined;
         this._accounts = new Map();
     }
-    getSelectedAccount() {
+    unsafeGetSelectedAccount() {
         if (this._selectedAccount === undefined) {
             throw Error('No account is selected yet');
         }
@@ -154,7 +174,7 @@ class SignerProviderWithCachedAccounts extends SignerProviderWithMultipleAccount
             return Promise.resolve(this._selectedAccount);
         }
     }
-    setSelectedAddress(address) {
+    setSelectedAccount(address) {
         const accountOpt = this._accounts.get(address);
         if (accountOpt === undefined) {
             throw Error('The address is not in the accounts');
@@ -176,23 +196,30 @@ class SignerProviderWithCachedAccounts extends SignerProviderWithMultipleAccount
     }
 }
 exports.SignerProviderWithCachedAccounts = SignerProviderWithCachedAccounts;
-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.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) {

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

@@ -2,13 +2,8 @@ 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">>;
-    };
+    static from(nodeProvider: NodeProvider): TransactionBuilder;
+    static from(baseUrl: string, apiKey?: string): TransactionBuilder;
     private static validatePublicKey;
     buildTransferTx(params: SignTransferTxParams, publicKey: string): Promise<Omit<SignTransferTxResult, 'signature'>>;
     buildDeployContractTx(params: SignDeployContractTxParams, publicKey: string): Promise<Omit<SignDeployContractTxResult, 'signature'>>;

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

@@ -23,25 +23,26 @@ 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);
+    static from(param0, param1) {
+        const nodeProvider = typeof param0 === 'string' ? new api_1.NodeProvider(param0, param1) : param0;
         return new (class extends TransactionBuilder {
             get nodeProvider() {
                 return nodeProvider;
             }
         })();
     }
-    static validatePublicKey(params, publicKey) {
-        const address = (0, utils_1.addressFromPublicKey)(publicKey);
+    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);
+        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
@@ -50,10 +51,11 @@ class TransactionBuilder {
         return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildDeployContractTx(params, publicKey) {
-        TransactionBuilder.validatePublicKey(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),
@@ -65,10 +67,11 @@ class TransactionBuilder {
         return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildExecuteScriptTx(params, publicKey) {
-        TransactionBuilder.validatePublicKey(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),

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

@@ -9,16 +9,20 @@ export interface Destination {
     lockTime?: number;
     message?: string;
 }
+export declare type KeyType = 'default' | 'bip340-schnorr';
 export interface Account {
+    keyType: KeyType;
     address: string;
     group: number;
     publicKey: string;
 }
 export declare type SignerAddress = {
     signerAddress: string;
+    signerKeyType?: KeyType;
 };
 export interface SignTransferTxParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     destinations: Destination[];
     utxos?: OutputRef[];
     gasAmount?: number;
@@ -35,6 +39,7 @@ export interface SignTransferTxResult {
 }
 export interface SignDeployContractTxParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     bytecode: string;
     initialAttoAlphAmount?: Number256;
     initialTokenAmounts?: Token[];
@@ -54,6 +59,7 @@ export interface SignDeployContractTxResult {
 }
 export interface SignExecuteScriptTxParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     bytecode: string;
     attoAlphAmount?: Number256;
     tokens?: Token[];
@@ -70,6 +76,7 @@ export interface SignExecuteScriptTxResult {
 }
 export interface SignUnsignedTxParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     unsignedTx: string;
 }
 export interface SignUnsignedTxResult {
@@ -81,9 +88,12 @@ export interface SignUnsignedTxResult {
     gasAmount: number;
     gasPrice: Number256;
 }
+export declare type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     message: string;
+    messageHasher: MessageHasher;
 }
 export interface SignMessageResult {
     signature: string;
@@ -99,21 +109,7 @@ export interface SubmissionResult {
 }
 export interface EnableOptionsBase {
     chainGroup?: number;
+    keyType?: KeyType;
     networkId: string;
-    onDisconnected: () => Promise<void>;
+    onDisconnected: () => Promise<void> | 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/transaction/sign-verify.d.ts

@@ -1,2 +1,3 @@
-export declare function transactionSign(txHash: string, privateKey: string): string;
-export declare function transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean;
+import { KeyType } from '../signer';
+export declare function transactionSign(txId: string, privateKey: string, keyType?: KeyType): string;
+export declare function transactionVerifySignature(txId: string, publicKey: string, signature: string, keyType?: KeyType): boolean;

package/dist/src/transaction/sign-verify.js

@@ -42,21 +42,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transactionVerifySignature = exports.transactionSign = void 0;
 const utils = __importStar(require("../utils"));
-const elliptic_1 = require("elliptic");
-const ec = new elliptic_1.ec('secp256k1');
-function transactionSign(txHash, privateKey) {
-    const keyPair = ec.keyFromPrivate(privateKey);
-    const signature = keyPair.sign(txHash);
-    return utils.encodeSignature(signature);
+function transactionSign(txId, privateKey, keyType) {
+    return utils.sign(txId, privateKey, keyType);
 }
 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;
-    }
+function transactionVerifySignature(txId, publicKey, signature, keyType) {
+    return utils.verifySignature(txId, publicKey, signature, keyType);
 }
 exports.transactionVerifySignature = transactionVerifySignature;

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

@@ -3,3 +3,5 @@ export * from './bs58';
 export * from './djb2';
 export * from './utils';
 export * from './subscription';
+export * from './sign';
+export * from './number';

package/dist/src/utils/index.js

@@ -36,3 +36,5 @@ __exportStar(require("./bs58"), exports);
 __exportStar(require("./djb2"), exports);
 __exportStar(require("./utils"), exports);
 __exportStar(require("./subscription"), exports);
+__exportStar(require("./sign"), exports);
+__exportStar(require("./number"), exports);

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

@@ -0,0 +1,18 @@
+import { Number256 } from '..';
+export declare const isNumeric: (numToCheck: any) => boolean;
+export interface IPrettifyNumberConfig {
+    minDecimalPlaces: number;
+    maxDecimalPlaces: number;
+    /** significant digits to show in decimals while respecting decimal places */
+    minDecimalSignificantDigits: number;
+    /** special case for zero, e.g. we may want to display $0.00 or 0.0 ALPH */
+    decimalPlacesWhenZero: number;
+}
+export declare const prettifyNumberConfig: Record<string, IPrettifyNumberConfig>;
+export declare function prettifyAttoAlphAmount(amount: Number256): string | undefined;
+export declare function prettifyTokenAmount(amount: Number256, decimals: number): string | undefined;
+export declare function prettifyExactAmount(amount: Number256, decimals: number): string | undefined;
+export declare function prettifyNumber(amount: Number256, decimals: number, config: IPrettifyNumberConfig): string | undefined;
+export declare function convertAmountWithDecimals(amount: string | number, decimals: number): bigint | undefined;
+export declare function convertAlphAmount(amount: string | number): bigint | undefined;
+export declare function number256ToBigint(number: Number256): bigint;

package/dist/src/utils/number.fixture.d.ts

@@ -0,0 +1,12 @@
+export declare const tests: {
+    raw: bigint;
+    decimal: number;
+    exact: string;
+    alphFormat: string;
+    tokenFormat: string;
+}[];
+export declare const tests1: {
+    raw: string;
+    decimals: number;
+    amount: bigint;
+}[];

package/dist/src/utils/number.fixture.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tests1 = exports.tests = void 0;
+/*
+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/>.
+*/
+exports.tests = [
+    {
+        raw: 123456n,
+        decimal: 5,
+        exact: '1.23456',
+        alphFormat: '1.23',
+        tokenFormat: '1.2346'
+    },
+    {
+        raw: 12345612n,
+        decimal: 2,
+        exact: '123,456.12',
+        alphFormat: '123,456.12',
+        tokenFormat: '123,456.12'
+    },
+    {
+        raw: 123456123456n,
+        decimal: 6,
+        exact: '123,456.123456',
+        alphFormat: '123,456.12',
+        tokenFormat: '123,456.1235'
+    },
+    {
+        raw: 12n,
+        decimal: 2,
+        exact: '0.12',
+        alphFormat: '0.12',
+        tokenFormat: '0.12'
+    },
+    {
+        raw: 123456n,
+        decimal: 6,
+        exact: '0.123456',
+        alphFormat: '0.12',
+        tokenFormat: '0.1235'
+    },
+    {
+        raw: 123456n,
+        decimal: 7,
+        exact: '0.0123456',
+        alphFormat: '0.012',
+        tokenFormat: '0.0123'
+    },
+    {
+        raw: 123456n,
+        decimal: 8,
+        exact: '0.00123456',
+        alphFormat: '0.0012',
+        tokenFormat: '0.0012'
+    },
+    {
+        raw: 123456n,
+        decimal: 9,
+        exact: '0.000123456',
+        alphFormat: '0.00012',
+        tokenFormat: '0.00012'
+    },
+    {
+        raw: 123456n,
+        decimal: 11,
+        exact: '0.00000123456',
+        alphFormat: '0.0000012',
+        tokenFormat: '0.0000012'
+    },
+    {
+        raw: -123456n,
+        decimal: 11,
+        exact: '-0.00000123456',
+        alphFormat: '-0.0000012',
+        tokenFormat: '-0.0000012'
+    },
+    {
+        raw: 8923088n,
+        decimal: 10,
+        exact: '0.0008923088',
+        alphFormat: '0.00089',
+        tokenFormat: '0.00089'
+    },
+    {
+        raw: 885n,
+        decimal: 6,
+        exact: '0.000885',
+        alphFormat: '0.00089',
+        tokenFormat: '0.00089'
+    },
+    {
+        raw: 100000000000n,
+        decimal: 18,
+        exact: '0.0000001',
+        alphFormat: '0.0000001',
+        tokenFormat: '0.0000001'
+    },
+    {
+        raw: 1504000000000000000n,
+        decimal: 18,
+        exact: '1.504',
+        alphFormat: '1.50',
+        tokenFormat: '1.504'
+    },
+    {
+        raw: 1505000000000000000n,
+        decimal: 18,
+        exact: '1.505',
+        alphFormat: '1.51',
+        tokenFormat: '1.505'
+    },
+    {
+        raw: 1500050000000000000n,
+        decimal: 18,
+        exact: '1.50005',
+        alphFormat: '1.50',
+        tokenFormat: '1.5001'
+    },
+    {
+        raw: 100n,
+        decimal: 0,
+        exact: '100',
+        alphFormat: '100.00',
+        tokenFormat: '100.0'
+    },
+    {
+        raw: 123456789n,
+        decimal: 0,
+        exact: '123,456,789',
+        alphFormat: '123,456,789.00',
+        tokenFormat: '123,456,789.0'
+    },
+    {
+        raw: -123456789n,
+        decimal: 0,
+        exact: '-123,456,789',
+        alphFormat: '-123,456,789.00',
+        tokenFormat: '-123,456,789.0'
+    },
+    {
+        raw: 0n,
+        decimal: 0,
+        exact: '0',
+        alphFormat: '0.00',
+        tokenFormat: '0.0'
+    }
+];
+exports.tests1 = [
+    {
+        raw: '0',
+        decimals: 18,
+        amount: 0n
+    },
+    {
+        raw: '1.23',
+        decimals: 2,
+        amount: 123n
+    },
+    {
+        raw: '1',
+        decimals: 5,
+        amount: 100000n
+    },
+    {
+        raw: '1',
+        decimals: 18,
+        amount: 1000000000000000000n
+    },
+    {
+        raw: '1.23456789',
+        decimals: 18,
+        amount: 1234567890000000000n
+    }
+];