@alephium/web3 0.5.0-rc.0 → 0.5.0-rc.10

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.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.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;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -54,6 +54,7 @@ const utils_1 = require("../utils");
 const global_1 = require("../global");
 const path = __importStar(require("path"));
 const events_1 = require("./events");
+const constants_1 = require("../constants");
 var SourceKind;
 (function (SourceKind) {
     SourceKind[SourceKind["Contract"] = 0] = "Contract";
@@ -578,34 +579,43 @@ class Contract extends Artifact {
         return contract.fromApiContractState(state);
     }
     static fromApiEvent(event, codeHash, txId) {
-        let eventSig;
+        let fields;
+        let name;
         if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-            eventSig = this.ContractCreatedEvent;
+            fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent);
+            name = Contract.ContractCreatedEvent.name;
         }
         else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-            eventSig = this.ContractDestroyedEvent;
+            fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent);
+            name = Contract.ContractDestroyedEvent.name;
         }
         else {
             const contract = Project.currentProject.contractByCodeHash(codeHash);
-            eventSig = contract.eventsSig[event.eventIndex];
+            const eventSig = contract.eventsSig[event.eventIndex];
+            fields = fromApiEventFields(event.fields, eventSig);
+            name = eventSig.name;
         }
         return {
             txId: txId,
             blockHash: event.blockHash,
             contractAddress: event.contractAddress,
-            name: eventSig.name,
+            name: name,
             eventIndex: event.eventIndex,
-            fields: fromApiEventFields(event.fields, eventSig)
+            fields: fields
         };
     }
-    fromApiTestContractResult(methodIndex, result, txId) {
+    fromApiTestContractResult(methodName, result, txId) {
+        const methodIndex = this.functions.findIndex((sig) => sig.name === methodName);
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
+        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
         addressToCodeHash.set(result.address, result.codeHash);
         result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
         return {
             contractId: (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(result.address)),
             contractAddress: result.address,
-            returns: (0, api_1.fromApiArray)(result.returns, this.functions[`${methodIndex}`].returnTypes),
+            returns: returns,
             gasUsed: result.gasUsed,
             contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
             txOutputs: result.txOutputs.map(fromApiOutput),
@@ -615,8 +625,10 @@ class Contract extends Artifact {
     }
     async txParamsForDeployment(signer, params) {
         const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
+        const selectedAccount = await signer.getSelectedAccount();
         const signerParams = {
-            signerAddress: await signer.getSelectedAddress(),
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
             bytecode: bytecode,
             initialAttoAlphAmount: params?.initialAttoAlphAmount,
             issueTokenAmount: params?.issueTokenAmount,
@@ -653,10 +665,11 @@ class Contract extends Artifact {
         };
     }
     fromApiCallContractResult(result, txId, methodIndex) {
+        const returnTypes = this.functions[`${methodIndex}`].returnTypes;
+        const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
+        const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
         const addressToCodeHash = new Map();
         result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
-        const functionSig = this.functions[`${methodIndex}`];
-        const returns = (0, api_1.fromApiArray)(result.returns, functionSig.returnTypes);
         return {
             returns: returns,
             gasUsed: result.gasUsed,
@@ -672,7 +685,9 @@ Contract.ContractCreatedEventIndex = -1;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
 };
 Contract.ContractDestroyedEventIndex = -2;
 Contract.ContractDestroyedEvent = {
@@ -717,8 +732,10 @@ class Script extends Artifact {
         return JSON.stringify(object, null, 2);
     }
     async txParamsForExecution(signer, params) {
+        const selectedAccount = await signer.getSelectedAccount();
         const signerParams = {
-            signerAddress: await signer.getSelectedAddress(),
+            signerAddress: selectedAccount.address,
+            signerKeyType: selectedAccount.keyType,
             bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
             attoAlphAmount: params.attoAlphAmount,
             tokens: params.tokens,
@@ -752,6 +769,9 @@ function fromApiFields(immFields, mutFields, fieldsSig) {
 function fromApiEventFields(vals, eventSig) {
     return (0, api_1.fromApiVals)(vals, eventSig.fieldNames, eventSig.fieldTypes);
 }
+function fromApiSystemEventFields(vals, systemEventSig) {
+    return (0, api_1.fromApiVals)(vals, systemEventSig.fieldNames, systemEventSig.fieldTypes, systemEventSig.optionalFieldNames ?? [], systemEventSig.optionalFieldTypes ?? []);
+}
 function toApiAsset(asset) {
     return {
         attoAlphAmount: (0, api_1.toApiNumber256)(asset.alphAmount),
@@ -856,27 +876,38 @@ class ContractFactory {
             instance: this.at(result.contractAddress)
         };
     }
+    // This is used for testing contract functions
+    stateForTest(initFields, asset, address) {
+        const newAsset = {
+            alphAmount: asset?.alphAmount ?? constants_1.ONE_ALPH,
+            tokens: asset?.tokens
+        };
+        return this.contract.toState(initFields, newAsset, address);
+    }
 }
 exports.ContractFactory = ContractFactory;
-function decodeFields(event, eventSig, eventIndex) {
+function decodeSystemEvent(event, systemEventSig, eventIndex) {
     if (event.eventIndex !== eventIndex) {
         throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
     }
-    return (0, api_1.fromApiVals)(event.fields, eventSig.fieldNames, eventSig.fieldTypes);
+    return fromApiSystemEventFields(event.fields, systemEventSig);
 }
 function decodeContractCreatedEvent(event) {
-    const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
+    const fields = decodeSystemEvent(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
     return {
         blockHash: event.blockHash,
         txId: event.txId,
         eventIndex: event.eventIndex,
         name: Contract.ContractCreatedEvent.name,
-        fields: { address: fields['address'] }
+        fields: {
+            address: fields['address'],
+            parentAddress: fields['parentAddress'] === undefined ? undefined : fields['parentAddress']
+        }
     };
 }
 exports.decodeContractCreatedEvent = decodeContractCreatedEvent;
 function decodeContractDestroyedEvent(event) {
-    const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
+    const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
     return {
         blockHash: event.blockHash,
         txId: event.txId,
@@ -904,3 +935,120 @@ function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, f
     return (0, events_1.subscribeToEvents)(opt, address, fromCount);
 }
 exports.subscribeEventsFromContract = subscribeEventsFromContract;
+async function testMethod(contract, methodName, params) {
+    const txId = params?.txId ?? randomTxId();
+    const apiParams = contract.contract.toApiTestContractParams(methodName, {
+        ...params,
+        txId: txId,
+        initialFields: params.initialFields === undefined ? {} : params.initialFields,
+        testArgs: params.testArgs === undefined ? {} : params.testArgs
+    });
+    const apiResult = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsTestContract(apiParams);
+    const testResult = contract.contract.fromApiTestContractResult(methodName, apiResult, txId);
+    contract.contract.printDebugMessages(methodName, testResult.debugMessages);
+    return testResult;
+}
+exports.testMethod = testMethod;
+class ContractInstance {
+    constructor(address) {
+        this.address = address;
+        this.contractId = (0, utils_1.binToHex)((0, utils_1.contractIdFromAddress)(address));
+        this.groupIndex = (0, utils_1.groupOfAddress)(address);
+    }
+}
+exports.ContractInstance = ContractInstance;
+async function fetchContractState(contract, instance) {
+    const contractState = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(instance.address, {
+        group: instance.groupIndex
+    });
+    const state = contract.contract.fromApiContractState(contractState);
+    return {
+        ...state,
+        fields: state.fields
+    };
+}
+exports.fetchContractState = fetchContractState;
+function subscribeContractCreatedEvent(instance, options, fromCount) {
+    return subscribeEventsFromContract(options, instance.address, Contract.ContractCreatedEventIndex, (event) => {
+        return {
+            ...decodeContractCreatedEvent(event),
+            contractAddress: instance.address
+        };
+    }, fromCount);
+}
+exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
+function subscribeContractDestroyedEvent(instance, options, fromCount) {
+    return subscribeEventsFromContract(options, instance.address, Contract.ContractDestroyedEventIndex, (event) => {
+        return {
+            ...decodeContractDestroyedEvent(event),
+            contractAddress: instance.address
+        };
+    }, fromCount);
+}
+exports.subscribeContractDestroyedEvent = subscribeContractDestroyedEvent;
+function decodeEvent(contract, instance, event, targetEventIndex) {
+    if (event.eventIndex !== targetEventIndex &&
+        !(targetEventIndex >= 0 && targetEventIndex < contract.eventsSig.length)) {
+        throw new Error('Invalid event index: ' + event.eventIndex + ', expected: ' + targetEventIndex);
+    }
+    const eventSig = contract.eventsSig[`${targetEventIndex}`];
+    const fieldNames = eventSig.fieldNames;
+    const fieldTypes = eventSig.fieldTypes;
+    const fields = (0, api_1.fromApiVals)(event.fields, fieldNames, fieldTypes);
+    return {
+        contractAddress: instance.address,
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: eventSig.name,
+        fields: fields
+    };
+}
+exports.decodeEvent = decodeEvent;
+function subscribeContractEvent(contract, instance, options, eventName, fromCount) {
+    const eventIndex = contract.eventsSig.findIndex((sig) => sig.name === eventName);
+    return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
+}
+exports.subscribeContractEvent = subscribeContractEvent;
+function subscribeAllEvents(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
+                });
+        }
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback
+    };
+    return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
+}
+exports.subscribeAllEvents = subscribeAllEvents;
+async function callMethod(contract, instance, methodName, params) {
+    const methodIndex = contract.contract.getMethodIndex(methodName);
+    const txId = params?.txId ?? randomTxId();
+    const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
+    const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsCallContract(callParams);
+    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex);
+    return callResult;
+}
+exports.callMethod = callMethod;

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

@@ -1,32 +1,32 @@
 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, ExtSignTransferTxParams, ExtSignDeployContractTxParams, ExtSignExecuteScriptTxParams, ExtSignUnsignedTxParams, ExtSignMessageParams, KeyType } 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>;
+    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 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 +45,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 +53,12 @@ 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 verifySignedMessage(message: string, 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,37 @@ 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.SignerProviderWithCachedAccounts = exports.SignerProviderWithMultipleAccounts = exports.SignerProviderSimple = exports.InteractiveSignerProvider = exports.SignerProvider = void 0;
 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 +109,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 +117,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,12 +125,12 @@ 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 };
     }
@@ -146,7 +165,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 +173,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 +195,13 @@ 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) {
+function verifySignedMessage(message, publicKey, signature, keyType) {
     const extendedMessage = extendMessage(message);
     const messageHash = blakejs_1.default.blake2b(extendedMessage, undefined, 32);
-    return verifyHexString(utils.binToHex(messageHash), publicKey, signature);
+    return utils.verifySignature(utils.binToHex(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 ?? 'default');
         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 ?? 'default');
         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 ?? 'default');
         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 {
@@ -83,6 +90,7 @@ export interface SignUnsignedTxResult {
 }
 export interface SignMessageParams {
     signerAddress: string;
+    signerKeyType?: KeyType;
     message: string;
 }
 export interface SignMessageResult {

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;