@alephium/web3 0.5.0-rc.9 → 0.5.1

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

@@ -1,45 +1,5 @@
-import { Api as NodeApi } from './api-alephium';
-export interface ApiRequestArguments {
-    path: string;
-    method: string;
-    params: any[];
-}
-export declare type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
-export declare class NodeProvider {
-    readonly wallets: NodeApi<string>['wallets'];
-    readonly infos: NodeApi<string>['infos'];
-    readonly blockflow: NodeApi<string>['blockflow'];
-    readonly addresses: NodeApi<string>['addresses'];
-    readonly transactions: NodeApi<string>['transactions'];
-    readonly mempool: NodeApi<string>['mempool'];
-    readonly contracts: NodeApi<string>['contracts'];
-    readonly multisig: NodeApi<string>['multisig'];
-    readonly utils: NodeApi<string>['utils'];
-    readonly miners: NodeApi<string>['miners'];
-    readonly events: NodeApi<string>['events'];
-    constructor(baseUrl: string, apiKey?: string);
-    constructor(provider: NodeProvider);
-    constructor(handler: ApiRequestHandler);
-    request: (args: ApiRequestArguments) => Promise<any>;
-    static Proxy(nodeProvider: NodeProvider): NodeProvider;
-    static Remote(handler: ApiRequestHandler): NodeProvider;
-}
-export declare class ExplorerProvider {
-    readonly blocks: any;
-    readonly transactions: any;
-    readonly addresses: any;
-    readonly infos: any;
-    readonly unconfirmedTransactions: any;
-    readonly tokens: any;
-    readonly charts: any;
-    readonly utils: any;
-    constructor(baseUrl: string, apiKey?: string);
-    constructor(provider: ExplorerProvider);
-    constructor(handler: ApiRequestHandler);
-    request: (args: ApiRequestArguments) => Promise<any>;
-    static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider;
-    static Remote(handler: ApiRequestHandler): ExplorerProvider;
-}
+export * from './node-provider';
+export * from './explorer-provider';
 export * as node from './api-alephium';
 export * as explorer from './api-explorer';
 export * from './types';

package/dist/src/api/index.js

@@ -32,6 +32,9 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
+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);
+};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -39,124 +42,10 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-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.explorer = exports.node = exports.ExplorerProvider = exports.NodeProvider = void 0;
-const api_alephium_1 = require("./api-alephium");
-const api_explorer_1 = require("./api-explorer");
-function forwardRequests(api, handler) {
-    // Update class properties to forward requests
-    for (const [path, pathObject] of Object.entries(api)) {
-        for (const method of Object.keys(pathObject)) {
-            pathObject[`${method}`] = async (...params) => {
-                return handler({ path, method, params });
-            };
-        }
-    }
-}
-async function request(provider, args) {
-    const call = provider[`${args.path}`][`${args.method}`];
-    return call(...args.params);
-}
-function initializeNodeApi(baseUrl, apiKey) {
-    const nodeApi = new api_alephium_1.Api({
-        baseUrl: baseUrl,
-        baseApiParams: { secure: true },
-        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-    });
-    nodeApi.setSecurityData(apiKey ?? null);
-    return nodeApi;
-}
-class NodeProvider {
-    constructor(param0, apiKey) {
-        this.request = (args) => {
-            return request(this, args);
-        };
-        let nodeApi;
-        if (typeof param0 === 'string') {
-            nodeApi = initializeNodeApi(param0, apiKey);
-        }
-        else if (typeof param0 === 'function') {
-            nodeApi = new NodeProvider('https://1.2.3.4:0');
-            forwardRequests(nodeApi, param0);
-        }
-        else {
-            nodeApi = param0;
-        }
-        this.wallets = { ...nodeApi.wallets };
-        this.infos = { ...nodeApi.infos };
-        this.blockflow = { ...nodeApi.blockflow };
-        this.addresses = { ...nodeApi.addresses };
-        this.transactions = { ...nodeApi.transactions };
-        this.mempool = { ...nodeApi.mempool };
-        this.contracts = { ...nodeApi.contracts };
-        this.multisig = { ...nodeApi.multisig };
-        this.utils = { ...nodeApi.utils };
-        this.miners = { ...nodeApi.miners };
-        this.events = { ...nodeApi.events };
-    }
-    // This can prevent the proxied node provider from being modified
-    static Proxy(nodeProvider) {
-        return new NodeProvider(nodeProvider);
-    }
-    static Remote(handler) {
-        return new NodeProvider(handler);
-    }
-}
-exports.NodeProvider = NodeProvider;
-function initializeExplorerApi(baseUrl, apiKey) {
-    const explorerApi = new api_explorer_1.Api({
-        baseUrl: baseUrl,
-        baseApiParams: { secure: true },
-        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-    });
-    explorerApi.setSecurityData(apiKey ?? null);
-    return explorerApi;
-}
-class ExplorerProvider {
-    constructor(param0, apiKey) {
-        this.blocks = api_explorer_1.Api['blocks'];
-        this.transactions = api_explorer_1.Api['transactions'];
-        this.addresses = api_explorer_1.Api['addresses'];
-        this.infos = api_explorer_1.Api['infos'];
-        this.unconfirmedTransactions = api_explorer_1.Api['unconfirmedTransactions'];
-        this.tokens = api_explorer_1.Api['tokens'];
-        this.charts = api_explorer_1.Api['charts'];
-        this.utils = api_explorer_1.Api['utils'];
-        this.request = (args) => {
-            return request(this, args);
-        };
-        let explorerApi;
-        if (typeof param0 === 'string') {
-            explorerApi = initializeExplorerApi(param0, apiKey);
-        }
-        else if (typeof param0 === 'function') {
-            explorerApi = new ExplorerProvider('https://1.2.3.4:0');
-            forwardRequests(explorerApi, param0);
-        }
-        else {
-            explorerApi = param0;
-        }
-        this.blocks = { ...explorerApi.blocks };
-        this.transactions = { ...explorerApi.transactions };
-        this.addresses = { ...explorerApi.addresses };
-        this.infos = { ...explorerApi.infos };
-        this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions };
-        this.tokens = { ...explorerApi.tokens };
-        this.charts = { ...explorerApi.charts };
-        this.utils = { ...explorerApi.utils };
-    }
-    // This can prevent the proxied explorer provider from being modified
-    static Proxy(explorerProvider) {
-        return new ExplorerProvider(explorerProvider);
-    }
-    static Remote(handler) {
-        return new ExplorerProvider(handler);
-    }
-}
-exports.ExplorerProvider = ExplorerProvider;
+exports.explorer = exports.node = void 0;
+__exportStar(require("./node-provider"), exports);
+__exportStar(require("./explorer-provider"), exports);
 exports.node = __importStar(require("./api-alephium"));
 exports.explorer = __importStar(require("./api-explorer"));
 __exportStar(require("./types"), exports);

package/dist/src/api/node-provider.d.ts

@@ -0,0 +1,21 @@
+import { ApiRequestArguments, ApiRequestHandler } from './types';
+import { Api as NodeApi } from './api-alephium';
+export declare class NodeProvider {
+    readonly wallets: NodeApi<string>['wallets'];
+    readonly infos: NodeApi<string>['infos'];
+    readonly blockflow: NodeApi<string>['blockflow'];
+    readonly addresses: NodeApi<string>['addresses'];
+    readonly transactions: NodeApi<string>['transactions'];
+    readonly mempool: NodeApi<string>['mempool'];
+    readonly contracts: NodeApi<string>['contracts'];
+    readonly multisig: NodeApi<string>['multisig'];
+    readonly utils: NodeApi<string>['utils'];
+    readonly miners: NodeApi<string>['miners'];
+    readonly events: NodeApi<string>['events'];
+    constructor(baseUrl: string, apiKey?: string);
+    constructor(provider: NodeProvider);
+    constructor(handler: ApiRequestHandler);
+    request: (args: ApiRequestArguments) => Promise<any>;
+    static Proxy(nodeProvider: NodeProvider): NodeProvider;
+    static Remote(handler: ApiRequestHandler): NodeProvider;
+}

package/dist/src/api/node-provider.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/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProvider = void 0;
+const types_1 = require("./types");
+const api_alephium_1 = require("./api-alephium");
+function initializeNodeApi(baseUrl, apiKey) {
+    const nodeApi = new api_alephium_1.Api({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+    });
+    nodeApi.setSecurityData(apiKey ?? null);
+    return nodeApi;
+}
+class NodeProvider {
+    constructor(param0, apiKey) {
+        this.request = (args) => {
+            return (0, types_1.request)(this, args);
+        };
+        let nodeApi;
+        if (typeof param0 === 'string') {
+            nodeApi = initializeNodeApi(param0, apiKey);
+        }
+        else if (typeof param0 === 'function') {
+            nodeApi = new NodeProvider('https://1.2.3.4:0');
+            (0, types_1.forwardRequests)(nodeApi, param0);
+        }
+        else {
+            nodeApi = param0;
+        }
+        this.wallets = { ...nodeApi.wallets };
+        this.infos = { ...nodeApi.infos };
+        this.blockflow = { ...nodeApi.blockflow };
+        this.addresses = { ...nodeApi.addresses };
+        this.transactions = { ...nodeApi.transactions };
+        this.mempool = { ...nodeApi.mempool };
+        this.contracts = { ...nodeApi.contracts };
+        this.multisig = { ...nodeApi.multisig };
+        this.utils = { ...nodeApi.utils };
+        this.miners = { ...nodeApi.miners };
+        this.events = { ...nodeApi.events };
+    }
+    // This can prevent the proxied node provider from being modified
+    static Proxy(nodeProvider) {
+        return new NodeProvider(nodeProvider);
+    }
+    static Remote(handler) {
+        return new NodeProvider(handler);
+    }
+}
+exports.NodeProvider = NodeProvider;

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

@@ -1,5 +1,5 @@
 import * as node from './api-alephium';
-export declare type Number256 = bigint;
+export declare type Number256 = bigint | string;
 export declare type Val = Number256 | boolean | string | Val[];
 export declare type NamedVals = Record<string, Val>;
 export interface Token {
@@ -22,3 +22,11 @@ export declare function fromApiVals(vals: node.Val[], names: string[], types: st
 export declare function fromApiArray(vals: node.Val[], types: string[]): Val[];
 export declare function fromApiVal(v: node.Val, tpe: string): Val;
 export declare function typeLength(tpe: string): number;
+export interface ApiRequestArguments {
+    path: string;
+    method: string;
+    params: any[];
+}
+export declare type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
+export declare function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void;
+export declare function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any>;

package/dist/src/api/types.js

@@ -17,7 +17,7 @@ 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.typeLength = exports.fromApiVal = exports.fromApiArray = exports.fromApiVals = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = void 0;
+exports.request = exports.forwardRequests = exports.typeLength = exports.fromApiVal = exports.fromApiArray = exports.fromApiVals = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = void 0;
 const utils_1 = require("../utils");
 utils_1.assertType;
 function toApiToken(token) {
@@ -245,3 +245,19 @@ function typeLength(tpe) {
     return dims.reduce((a, b) => a * b);
 }
 exports.typeLength = typeLength;
+function forwardRequests(api, handler) {
+    // Update class properties to forward requests
+    for (const [path, pathObject] of Object.entries(api)) {
+        for (const method of Object.keys(pathObject)) {
+            pathObject[`${method}`] = async (...params) => {
+                return handler({ path, method, params });
+            };
+        }
+    }
+}
+exports.forwardRequests = forwardRequests;
+async function request(provider, args) {
+    const call = provider[`${args.path}`][`${args.method}`];
+    return call(...args.params);
+}
+exports.request = request;

package/dist/src/contract/contract.d.ts

@@ -257,6 +257,8 @@ export interface CallContractResult<R> {
     txOutputs: Output[];
     events: ContractEvent[];
 }
+export declare const CreateContractEventAddress: string;
+export declare const DestroyContractEventAddress: string;
 export interface SystemEventSig extends EventSig {
     optionalFieldNames?: string[];
     optionalFieldTypes?: string[];
@@ -279,10 +281,11 @@ export declare abstract class ContractInstance {
     constructor(address: Address);
 }
 export declare function fetchContractState<F extends Fields, I extends ContractInstance>(contract: ContractFactory<I, F>, instance: ContractInstance): Promise<ContractState<F>>;
-export declare function subscribeContractCreatedEvent(instance: ContractInstance, options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
-export declare function subscribeContractDestroyedEvent(instance: ContractInstance, options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractCreatedEvent(options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractDestroyedEvent(options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: SubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
-export declare function subscribeAllEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
+export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>): Promise<CallContractResult<R>>;
+export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export {};

package/dist/src/contract/contract.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callMethod = exports.subscribeAllEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.getContractEventsCurrentCount = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -886,6 +886,13 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
+function specialContractAddress(n) {
+    const bytes = new Uint8Array(32).fill(0);
+    bytes[31] = n;
+    return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
+}
+exports.CreateContractEventAddress = specialContractAddress(-1);
+exports.DestroyContractEventAddress = specialContractAddress(-2);
 function decodeSystemEvent(event, systemEventSig, eventIndex) {
     if (event.eventIndex !== eventIndex) {
         throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
@@ -968,20 +975,20 @@ async function fetchContractState(contract, instance) {
     };
 }
 exports.fetchContractState = fetchContractState;
-function subscribeContractCreatedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractCreatedEventIndex, (event) => {
+function subscribeContractCreatedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.CreateContractEventAddress, Contract.ContractCreatedEventIndex, (event) => {
         return {
             ...decodeContractCreatedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.CreateContractEventAddress
         };
     }, fromCount);
 }
 exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
-function subscribeContractDestroyedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractDestroyedEventIndex, (event) => {
+function subscribeContractDestroyedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.DestroyContractEventAddress, Contract.ContractDestroyedEventIndex, (event) => {
         return {
             ...decodeContractDestroyedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.DestroyContractEventAddress
         };
     }, fromCount);
 }
@@ -1010,27 +1017,12 @@ function subscribeContractEvent(contract, instance, options, eventName, fromCoun
     return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
 }
 exports.subscribeContractEvent = subscribeContractEvent;
-function subscribeAllEvents(contract, instance, options, fromCount) {
+function subscribeContractEvents(contract, instance, options, fromCount) {
     const messageCallback = (event) => {
-        switch (event.eventIndex) {
-            case Contract.ContractCreatedEventIndex: {
-                return options.messageCallback({
-                    ...decodeContractCreatedEvent(event),
-                    contractAddress: instance.address
-                });
-            }
-            case Contract.ContractDestroyedEventIndex: {
-                return options.messageCallback({
-                    ...decodeContractDestroyedEvent(event),
-                    contractAddress: instance.address
-                });
-            }
-            default:
-                return options.messageCallback({
-                    ...decodeEvent(contract, instance, event, event.eventIndex),
-                    contractAddress: instance.address
-                });
-        }
+        return options.messageCallback({
+            ...decodeEvent(contract, instance, event, event.eventIndex),
+            contractAddress: instance.address
+        });
     };
     const errorCallback = (err, subscription) => {
         return options.errorCallback(err, subscription);
@@ -1042,7 +1034,7 @@ function subscribeAllEvents(contract, instance, options, fromCount) {
     };
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
-exports.subscribeAllEvents = subscribeAllEvents;
+exports.subscribeContractEvents = subscribeContractEvents;
 async function callMethod(contract, instance, methodName, params) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const txId = params?.txId ?? randomTxId();
@@ -1052,3 +1044,14 @@ async function callMethod(contract, instance, methodName, params) {
     return callResult;
 }
 exports.callMethod = callMethod;
+async function getContractEventsCurrentCount(contractAddress) {
+    return (0, global_1.getCurrentNodeProvider)()
+        .events.getEventsContractContractaddressCurrentCount(contractAddress)
+        .catch((error) => {
+        if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+            return 0;
+        }
+        throw error;
+    });
+}
+exports.getContractEventsCurrentCount = getContractEventsCurrentCount;

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

@@ -1,6 +1,6 @@
 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, ExtSignTransferTxParams, ExtSignDeployContractTxParams, ExtSignExecuteScriptTxParams, ExtSignUnsignedTxParams, ExtSignMessageParams, KeyType } from './types';
+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;
@@ -18,12 +18,6 @@ export declare abstract class InteractiveSignerProvider<EnableOptions extends En
     protected abstract unsafeEnable(opt?: EnableOptions): Promise<Account>;
     enable(opt?: EnableOptions): Promise<Account>;
     abstract disconnect(): Promise<void>;
-    abstract signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>;
-    abstract signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>;
-    abstract signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>;
-    abstract signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    abstract signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>;
-    abstract signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>;
 }
 export declare abstract class SignerProviderSimple extends SignerProvider {
     abstract get nodeProvider(): NodeProvider;
@@ -58,7 +52,9 @@ export declare abstract class SignerProviderWithCachedAccounts<T extends Account
     getAccounts(): Promise<T[]>;
     getAccount(address: string): Promise<T>;
 }
-export declare function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): 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,7 +43,9 @@ 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.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = exports.InteractiveSignerProvider = exports.SignerProvider = void 0;
+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"));
@@ -135,9 +137,8 @@ class SignerProviderSimple extends SignerProvider {
         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 };
     }
 }
@@ -198,10 +199,27 @@ exports.SignerProviderWithCachedAccounts = SignerProviderWithCachedAccounts;
 function extendMessage(message) {
     return 'Alephium Signed Message: ' + message;
 }
-function verifySignedMessage(message, publicKey, signature, keyType) {
-    const extendedMessage = extendMessage(message);
-    const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
-    return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType);
+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/types.d.ts

@@ -88,10 +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;
@@ -107,21 +109,7 @@ export interface SubmissionResult {
 }
 export interface EnableOptionsBase {
     chainGroup?: number;
-    networkId: string;
-    onDisconnected: () => Promise<void>;
+    keyType?: KeyType;
+    networkId?: string;
+    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/utils/index.d.ts

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

package/dist/src/utils/index.js

@@ -37,3 +37,4 @@ __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;
+}[];