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

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/api/types.d.ts

@@ -18,7 +18,7 @@ export declare function toApiByteVec(v: Val): string;
 export declare function toApiAddress(v: Val): string;
 export declare function toApiArray(tpe: string, v: Val): node.Val;
 export declare function toApiVal(v: Val, tpe: string): node.Val;
-export declare function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals;
+export declare function fromApiVals(vals: node.Val[], names: string[], types: string[], optionalNames?: string[], optionalTypes?: string[]): NamedVals;
 export declare function fromApiArray(vals: node.Val[], types: string[]): Val[];
 export declare function fromApiVal(v: node.Val, tpe: string): Val;
 export declare function typeLength(tpe: string): number;

package/dist/src/api/types.js

@@ -165,7 +165,7 @@ function _fromApiVal(vals, valIndex, tpe) {
         }
     }
 }
-function fromApiVals(vals, names, types) {
+function fromApiVals(vals, names, types, optionalNames = [], optionalTypes = []) {
     let valIndex = 0;
     const result = {};
     types.forEach((currentType, index) => {
@@ -174,7 +174,11 @@ function fromApiVals(vals, names, types) {
         valIndex = nextIndex;
         result[`${currentName}`] = val;
     });
-    return result;
+    if (valIndex === vals.length) {
+        return result;
+    }
+    const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes);
+    return { ...result, ...optionalFields };
 }
 exports.fromApiVals = fromApiVals;
 function fromApiArray(vals, types) {

package/dist/src/constants.d.ts

@@ -2,3 +2,4 @@ export declare const TOTAL_NUMBER_OF_GROUPS = 4;
 export declare const MIN_UTXO_SET_AMOUNT: bigint;
 export declare const ALPH_TOKEN_ID: string;
 export declare const ONE_ALPH: bigint;
+export declare const DUST_AMOUNT: bigint;

package/dist/src/constants.js

@@ -17,8 +17,9 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ONE_ALPH = exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
+exports.DUST_AMOUNT = exports.ONE_ALPH = exports.ALPH_TOKEN_ID = exports.MIN_UTXO_SET_AMOUNT = exports.TOTAL_NUMBER_OF_GROUPS = void 0;
 exports.TOTAL_NUMBER_OF_GROUPS = 4;
 exports.MIN_UTXO_SET_AMOUNT = BigInt(1000000000000);
 exports.ALPH_TOKEN_ID = ''.padStart(64, '0');
 exports.ONE_ALPH = 10n ** 18n;
+exports.DUST_AMOUNT = 10n ** 15n;

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

@@ -123,9 +123,9 @@ export declare class Contract extends Artifact {
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
     static fromApiContractState(state: node.ContractState): ContractState;
     static ContractCreatedEventIndex: number;
-    static ContractCreatedEvent: EventSig;
+    static ContractCreatedEvent: SystemEventSig;
     static ContractDestroyedEventIndex: number;
-    static ContractDestroyedEvent: EventSig;
+    static ContractDestroyedEvent: SystemEventSig;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent;
     fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
@@ -257,11 +257,16 @@ export interface CallContractResult<R> {
     txOutputs: Output[];
     events: ContractEvent[];
 }
+export interface SystemEventSig extends EventSig {
+    optionalFieldNames?: string[];
+    optionalFieldTypes?: string[];
+}
 export declare type ContractCreatedEvent = ContractEvent<{
-    address: HexString;
+    address: Address;
+    parentAddress?: Address;
 }>;
 export declare type ContractDestroyedEvent = ContractEvent<{
-    address: HexString;
+    address: Address;
 }>;
 export declare function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'>;
 export declare function decodeContractDestroyedEvent(event: node.ContractEvent): Omit<ContractDestroyedEvent, 'contractAddress'>;

package/dist/src/contract/contract.js

@@ -579,24 +579,29 @@ 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(methodName, result, txId) {
@@ -620,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,
@@ -678,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 = {
@@ -723,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,
@@ -758,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),
@@ -872,25 +886,28 @@ class ContractFactory {
     }
 }
 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,

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