@alephium/web3 0.5.0-rc.6 → 0.5.0-rc.8

package/dist/src/api/api-alephium.d.ts

@@ -145,9 +145,11 @@ export interface BrokerInfo {
     };
 }
 export interface BuildDeployContractTx {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
     /** @format hex-string */
+    fromPublicKeyType?: string;
+    /** @format hex-string */
     bytecode: string;
     /** @format uint256 */
     initialAttoAlphAmount?: string;
@@ -177,9 +179,11 @@ export interface BuildDeployContractTxResult {
     contractAddress: string;
 }
 export interface BuildExecuteScriptTx {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
     /** @format hex-string */
+    fromPublicKeyType?: string;
+    /** @format hex-string */
     bytecode: string;
     /** @format uint256 */
     attoAlphAmount?: string;
@@ -249,8 +253,10 @@ export interface BuildSweepAddressTransactionsResult {
     toGroup: number;
 }
 export interface BuildTransaction {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
+    /** @format hex-string */
+    fromPublicKeyType?: string;
     destinations: Destination[];
     utxos?: OutputRef[];
     /** @format gas */
@@ -519,6 +525,13 @@ export interface InternalServerError {
 export interface MemPooled {
     type: string;
 }
+export interface MempoolTransactions {
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    transactions: TransactionTemplate[];
+}
 export interface MinerAddresses {
     addresses: string[];
 }
@@ -756,13 +769,6 @@ export interface Unban {
     peers: string[];
     type: string;
 }
-export interface UnconfirmedTransactions {
-    /** @format int32 */
-    fromGroup: number;
-    /** @format int32 */
-    toGroup: number;
-    unconfirmedTransactions: TransactionTemplate[];
-}
 export interface Unreachable {
     peers: string[];
     type: string;
@@ -910,7 +916,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.7.0
+ * @version 1.7.1
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1323,15 +1329,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
         getAddressesAddressGroup: (address: string, params?: RequestParams) => Promise<Group>;
     };
     transactions: {
-        /**
-         * No description
-         *
-         * @tags Transactions
-         * @name GetTransactionsUnconfirmed
-         * @summary List unconfirmed transactions
-         * @request GET:/transactions/unconfirmed
-         */
-        getTransactionsUnconfirmed: (params?: RequestParams) => Promise<UnconfirmedTransactions[]>;
         /**
          * No description
          *
@@ -1394,6 +1391,46 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             toGroup?: number;
         }, params?: RequestParams) => Promise<Confirmed | MemPooled | TxNotFound>;
     };
+    mempool: {
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name GetMempoolTransactions
+         * @summary List mempool transactions
+         * @request GET:/mempool/transactions
+         */
+        getMempoolTransactions: (params?: RequestParams) => Promise<MempoolTransactions[]>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name DeleteMempoolTransactions
+         * @summary Remove all transactions from mempool
+         * @request DELETE:/mempool/transactions
+         */
+        deleteMempoolTransactions: (params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name PutMempoolTransactionsRebroadcast
+         * @summary Rebroadcase a mempool transaction to the network
+         * @request PUT:/mempool/transactions/rebroadcast
+         */
+        putMempoolTransactionsRebroadcast: (query: {
+            txId: string;
+        }, params?: RequestParams) => Promise<void>;
+        /**
+         * No description
+         *
+         * @tags Mempool
+         * @name PutMempoolTransactionsValidate
+         * @summary Validate all mempool transactions and remove invalid ones
+         * @request PUT:/mempool/transactions/validate
+         */
+        putMempoolTransactionsValidate: (params?: RequestParams) => Promise<void>;
+    };
     contracts: {
         /**
          * No description

package/dist/src/api/api-alephium.js

@@ -149,7 +149,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.7.0
+ * @version 1.7.1
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -778,20 +778,6 @@ class Api extends HttpClient {
             }).then(utils_1.convertHttpResponse)
         };
         this.transactions = {
-            /**
-             * No description
-             *
-             * @tags Transactions
-             * @name GetTransactionsUnconfirmed
-             * @summary List unconfirmed transactions
-             * @request GET:/transactions/unconfirmed
-             */
-            getTransactionsUnconfirmed: (params = {}) => this.request({
-                path: `/transactions/unconfirmed`,
-                method: 'GET',
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse),
             /**
              * No description
              *
@@ -887,6 +873,62 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.mempool = {
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name GetMempoolTransactions
+             * @summary List mempool transactions
+             * @request GET:/mempool/transactions
+             */
+            getMempoolTransactions: (params = {}) => this.request({
+                path: `/mempool/transactions`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name DeleteMempoolTransactions
+             * @summary Remove all transactions from mempool
+             * @request DELETE:/mempool/transactions
+             */
+            deleteMempoolTransactions: (params = {}) => this.request({
+                path: `/mempool/transactions`,
+                method: 'DELETE',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name PutMempoolTransactionsRebroadcast
+             * @summary Rebroadcase a mempool transaction to the network
+             * @request PUT:/mempool/transactions/rebroadcast
+             */
+            putMempoolTransactionsRebroadcast: (query, params = {}) => this.request({
+                path: `/mempool/transactions/rebroadcast`,
+                method: 'PUT',
+                query: query,
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Mempool
+             * @name PutMempoolTransactionsValidate
+             * @summary Validate all mempool transactions and remove invalid ones
+             * @request PUT:/mempool/transactions/validate
+             */
+            putMempoolTransactionsValidate: (params = {}) => this.request({
+                path: `/mempool/transactions/validate`,
+                method: 'PUT',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
         this.contracts = {
             /**
              * No description

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

@@ -11,6 +11,7 @@ export declare class NodeProvider {
     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'];

package/dist/src/api/index.js

@@ -90,6 +90,7 @@ class NodeProvider {
         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 };

package/dist/src/contract/contract.js

@@ -625,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,
@@ -730,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,

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);
         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 {
@@ -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;

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,4 @@ export * from './bs58';
 export * from './djb2';
 export * from './utils';
 export * from './subscription';
+export * from './sign';

package/dist/src/utils/index.js

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