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

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

@@ -0,0 +1,3 @@
+import { KeyType } from '../signer';
+export declare function sign(hash: string, privateKey: string, _keyType?: KeyType): string;
+export declare function verifySignature(hash: string, publicKey: string, signature: string, _keyType?: KeyType): boolean;

package/dist/src/utils/sign.js

@@ -0,0 +1,77 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = exports.sign = void 0;
+const elliptic_1 = require("elliptic");
+const __1 = require("..");
+const secp = __importStar(require("tiny-secp256k1"));
+const ec = new elliptic_1.ec('secp256k1');
+// hash has to be 32 bytes
+function sign(hash, privateKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const key = ec.keyFromPrivate(privateKey);
+        const signature = key.sign(hash);
+        return (0, __1.encodeSignature)(signature);
+    }
+    else {
+        const signature = secp.signSchnorr((0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(privateKey));
+        return (0, __1.binToHex)(signature);
+    }
+}
+exports.sign = sign;
+function verifySignature(hash, publicKey, signature, _keyType) {
+    const keyType = _keyType ?? 'default';
+    try {
+        if (keyType === 'default') {
+            const key = ec.keyFromPublic(publicKey, 'hex');
+            return key.verify(hash, (0, __1.signatureDecode)(ec, signature));
+        }
+        else {
+            return secp.verifySchnorr((0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(publicKey), (0, __1.hexToBinUnsafe)(signature));
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.verifySignature = verifySignature;

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

@@ -1,5 +1,6 @@
 import { ec as EC, SignatureInput } from 'elliptic';
 import BN from 'bn.js';
+import { KeyType } from '../signer';
 export declare function encodeSignature(signature: EC.Signature | {
     r: BN;
     s: BN;
@@ -13,9 +14,9 @@ export declare function contractIdFromAddress(address: string): Uint8Array;
 export declare function tokenIdFromAddress(address: string): Uint8Array;
 export declare function hexToBinUnsafe(hex: string): Uint8Array;
 export declare function binToHex(bin: Uint8Array): string;
-export declare function groupOfPrivateKey(privateKey: string): number;
-export declare function publicKeyFromPrivateKey(privateKey: string): string;
-export declare function addressFromPublicKey(publicKey: string): string;
+export declare function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number;
+export declare function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string;
+export declare function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string;
 export declare function addressFromContractId(contractId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;
 export declare function subContractId(parentContractId: string, pathInHex: string, group: number): string;

package/dist/src/utils/utils.js

@@ -153,20 +153,35 @@ function binToHex(bin) {
     return buffer_1.Buffer.from(bin).toString('hex');
 }
 exports.binToHex = binToHex;
-function groupOfPrivateKey(privateKey) {
-    return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey)));
+function groupOfPrivateKey(privateKey, keyType) {
+    return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType));
 }
 exports.groupOfPrivateKey = groupOfPrivateKey;
-function publicKeyFromPrivateKey(privateKey) {
-    const key = ec.keyFromPrivate(privateKey);
-    return key.getPublic(true, 'hex');
+function publicKeyFromPrivateKey(privateKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const key = ec.keyFromPrivate(privateKey);
+        return key.getPublic(true, 'hex');
+    }
+    else {
+        return ec.g.mul(new bn_js_1.default(privateKey, 16)).encode('hex', true).slice(2);
+    }
 }
 exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
-function addressFromPublicKey(publicKey) {
-    const addressType = buffer_1.Buffer.from([AddressType.P2PKH]);
-    const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
-    const bytes = buffer_1.Buffer.concat([addressType, hash]);
-    return bs58_1.default.encode(bytes);
+function addressFromPublicKey(publicKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const addressType = buffer_1.Buffer.from([AddressType.P2PKH]);
+        const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
+        const bytes = buffer_1.Buffer.concat([addressType, hash]);
+        return bs58_1.default.encode(bytes);
+    }
+    else {
+        const lockupScript = buffer_1.Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
+        const lockupScriptHash = blakejs_1.default.blake2b(lockupScript, undefined, 32);
+        const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
+        return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, lockupScriptHash]));
+    }
 }
 exports.addressFromPublicKey = addressFromPublicKey;
 function addressFromContractId(contractId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.5.0-rc.6",
+  "version": "0.5.0-rc.8",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/api/api-alephium.ts

@@ -202,9 +202,12 @@ export interface BrokerInfo {
 }
 
 export interface BuildDeployContractTx {
-  /** @format public-key */
+  /** @format hex-string */
   fromPublicKey: string
 
+  /** @format hex-string */
+  fromPublicKeyType?: string
+
   /** @format hex-string */
   bytecode: string
 
@@ -247,9 +250,12 @@ export interface BuildDeployContractTxResult {
 }
 
 export interface BuildExecuteScriptTx {
-  /** @format public-key */
+  /** @format hex-string */
   fromPublicKey: string
 
+  /** @format hex-string */
+  fromPublicKeyType?: string
+
   /** @format hex-string */
   bytecode: string
 
@@ -346,8 +352,11 @@ export interface BuildSweepAddressTransactionsResult {
 }
 
 export interface BuildTransaction {
-  /** @format public-key */
+  /** @format hex-string */
   fromPublicKey: string
+
+  /** @format hex-string */
+  fromPublicKeyType?: string
   destinations: Destination[]
   utxos?: OutputRef[]
 
@@ -695,6 +704,15 @@ export interface MemPooled {
   type: string
 }
 
+export interface MempoolTransactions {
+  /** @format int32 */
+  fromGroup: number
+
+  /** @format int32 */
+  toGroup: number
+  transactions: TransactionTemplate[]
+}
+
 export interface MinerAddresses {
   addresses: string[]
 }
@@ -1004,15 +1022,6 @@ export interface Unban {
   type: string
 }
 
-export interface UnconfirmedTransactions {
-  /** @format int32 */
-  fromGroup: number
-
-  /** @format int32 */
-  toGroup: number
-  unconfirmedTransactions: TransactionTemplate[]
-}
-
 export interface Unreachable {
   peers: string[]
   type: string
@@ -1334,7 +1343,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 1.7.0
+ * @version 1.7.1
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2070,25 +2079,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse)
   }
   transactions = {
-    /**
-     * No description
-     *
-     * @tags Transactions
-     * @name GetTransactionsUnconfirmed
-     * @summary List unconfirmed transactions
-     * @request GET:/transactions/unconfirmed
-     */
-    getTransactionsUnconfirmed: (params: RequestParams = {}) =>
-      this.request<
-        UnconfirmedTransactions[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
-      >({
-        path: `/transactions/unconfirmed`,
-        method: 'GET',
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
     /**
      * No description
      *
@@ -2211,6 +2201,72 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
+  mempool = {
+    /**
+     * No description
+     *
+     * @tags Mempool
+     * @name GetMempoolTransactions
+     * @summary List mempool transactions
+     * @request GET:/mempool/transactions
+     */
+    getMempoolTransactions: (params: RequestParams = {}) =>
+      this.request<
+        MempoolTransactions[],
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/mempool/transactions`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Mempool
+     * @name DeleteMempoolTransactions
+     * @summary Remove all transactions from mempool
+     * @request DELETE:/mempool/transactions
+     */
+    deleteMempoolTransactions: (params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/mempool/transactions`,
+        method: 'DELETE',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * 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 = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/mempool/transactions/rebroadcast`,
+        method: 'PUT',
+        query: query,
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Mempool
+     * @name PutMempoolTransactionsValidate
+     * @summary Validate all mempool transactions and remove invalid ones
+     * @request PUT:/mempool/transactions/validate
+     */
+    putMempoolTransactionsValidate: (params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/mempool/transactions/validate`,
+        method: 'PUT',
+        ...params
+      }).then(convertHttpResponse)
+  }
   contracts = {
     /**
      * No description

package/src/api/index.ts

@@ -58,6 +58,7 @@ export 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']
@@ -83,6 +84,7 @@ export 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/src/contract/contract.ts

@@ -920,8 +920,10 @@ export class Contract extends Artifact {
     params: DeployContractParams<P>
   ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {})
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: bytecode,
       initialAttoAlphAmount: params?.initialAttoAlphAmount,
       issueTokenAmount: params?.issueTokenAmount,
@@ -1063,8 +1065,10 @@ export class Script extends Artifact {
     signer: SignerProvider,
     params: ExecuteScriptParams<P>
   ): Promise<SignExecuteScriptTxParams> {
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
       attoAlphAmount: params.attoAlphAmount,
       tokens: params.tokens,
@@ -1289,7 +1293,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
 assertType<
   Eq<
     Omit<DeployContractParams<undefined>, 'initialFields'>,
-    Omit<SignDeployContractTxParams, 'signerAddress' | 'bytecode'>
+    Omit<SignDeployContractTxParams, 'signerAddress' | 'signerKeyType' | 'bytecode'>
   >
 >
 export type DeployContractResult<T> = SignDeployContractTxResult & { instance: T }

package/src/signer/signer.ts

@@ -16,7 +16,6 @@ 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/>.
 */
 
-import { ec as EC } from 'elliptic'
 import { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
@@ -43,53 +42,70 @@ import {
   ExtSignDeployContractTxParams,
   ExtSignExecuteScriptTxParams,
   ExtSignUnsignedTxParams,
-  ExtSignMessageParams
+  ExtSignMessageParams,
+  KeyType
 } from './types'
 import { TransactionBuilder } from './tx-builder'
+import { addressFromPublicKey, groupOfAddress } from '../utils'
 
-const ec = new EC('secp256k1')
+export abstract class SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
+  abstract get explorerProvider(): ExplorerProvider | undefined
 
-export interface SignerProvider {
-  get nodeProvider(): NodeProvider | undefined
-  get explorerProvider(): ExplorerProvider | undefined
+  protected abstract unsafeGetSelectedAccount(): Promise<Account>
+  async getSelectedAccount(): Promise<Account> {
+    const account = await this.unsafeGetSelectedAccount()
+    SignerProvider.validateAccount(account)
+    return account
+  }
 
-  getSelectedAddress(): Promise<Address>
+  static validateAccount(account: Account): void {
+    const derivedAddress = addressFromPublicKey(account.publicKey, account.keyType)
+    const derivedGroup = groupOfAddress(derivedAddress)
+    if (derivedAddress !== account.address || derivedGroup !== account.group) {
+      throw Error(`Invalid accounot data: ${JSON.stringify(account)}`)
+    }
+  }
 
-  signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
+  abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
 
-  signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
   // The message will be prefixed with 'Alephium Signed Message: ' before signing
   // so that the resulted signature cannot be reused for building transactions.
-  signMessage(params: SignMessageParams): Promise<SignMessageResult>
+  abstract signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
 // Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
-export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
-  extends SignerProvider {
-  enable(opt?: EnableOptions): Promise<Address>
-  disconnect(): Promise<void>
+export abstract class InteractiveSignerProvider<
+  EnableOptions extends EnableOptionsBase = EnableOptionsBase
+> extends SignerProvider {
+  protected abstract unsafeEnable(opt?: EnableOptions): Promise<Account>
+  async enable(opt?: EnableOptions): Promise<Account> {
+    const account = await this.unsafeEnable(opt)
+    SignerProvider.validateAccount(account)
+    return account
+  }
+
+  abstract disconnect(): Promise<void>
 
   // Methods inherited from SignerProvider, but require networkId in the params
-  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>
+  abstract override signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
+  abstract override signAndSubmitDeployContractTx(
+    params: ExtSignDeployContractTxParams
+  ): Promise<SignDeployContractTxResult>
+  abstract override signAndSubmitExecuteScriptTx(
+    params: ExtSignExecuteScriptTxParams
+  ): Promise<SignExecuteScriptTxResult>
+  abstract override signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract override signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract override signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
 }
 
-export abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
-  abstract get explorerProvider(): ExplorerProvider | undefined
-
-  abstract getSelectedAccount(): Promise<Account>
-
-  async getSelectedAddress(): Promise<Address> {
-    const account = await this.getSelectedAccount()
-    return account.address
-  }
+export abstract class SignerProviderSimple extends SignerProvider {
+  abstract override get nodeProvider(): NodeProvider
 
   async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
     const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
@@ -133,8 +149,11 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
-    return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress))
+  async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    return TransactionBuilder.from(this.nodeProvider).buildTransferTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -143,10 +162,13 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildDeployContractTx(
+  async buildDeployContractTx(
     params: SignDeployContractTxParams
   ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
-    return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress))
+    return TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -155,16 +177,17 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildExecuteScriptTx(
-    params: SignExecuteScriptTxParams
-  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
-    return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress))
+  async buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    return 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: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
-    const response = await this.buildUnsignedTx(params)
+    const response = await TransactionBuilder.from(this.nodeProvider).buildUnsignedTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
     return { signature, ...response }
   }
@@ -180,7 +203,7 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
 }
 
 export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
-  abstract setSelectedAddress(address: string): Promise<void>
+  abstract setSelectedAccount(address: string): Promise<void>
 
   abstract getAccounts(): Promise<Account[]>
 
@@ -204,7 +227,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   private _selectedAccount: T | undefined = undefined
   protected readonly _accounts = new Map<Address, T>()
 
-  getSelectedAccount(): Promise<T> {
+  protected unsafeGetSelectedAccount(): Promise<T> {
     if (this._selectedAccount === undefined) {
       throw Error('No account is selected yet')
     } else {
@@ -212,7 +235,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
     }
   }
 
-  setSelectedAddress(address: string): Promise<void> {
+  setSelectedAccount(address: string): Promise<void> {
     const accountOpt = this._accounts.get(address)
     if (accountOpt === undefined) {
       throw Error('The address is not in the accounts')
@@ -236,23 +259,14 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   }
 }
 
-export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
-  try {
-    const key = ec.keyFromPublic(publicKey, 'hex')
-    return key.verify(hexString, utils.signatureDecode(ec, signature))
-  } catch (error) {
-    return false
-  }
-}
-
 function extendMessage(message: string): string {
   return 'Alephium Signed Message: ' + message
 }
 
-export function verifySignedMessage(message: string, publicKey: string, signature: string): boolean {
+export function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): boolean {
   const extendedMessage = extendMessage(message)
   const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-  return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
+  return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType)
 }
 
 export function toApiDestination(data: Destination): node.Destination {