@dedot/contracts 0.13.2 → 0.14.0

package/cjs/errors.js

@@ -3,6 +3,19 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isContractInstantiateLangError = exports.isContractInstantiateDispatchError = exports.isContractInstantiateError = exports.isContractLangError = exports.isContractDispatchError = exports.isContractExecutionError = exports.ContractLangError = exports.ContractDispatchError = exports.ContractExecutionError = exports.ContractInstantiateLangError = exports.ContractInstantiateDispatchError = exports.ContractInstantiateError = void 0;
 const utils_1 = require("@dedot/utils");
 const index_js_1 = require("./utils/index.js");
+const formatDispatchError = (err, moduleError) => {
+    if (moduleError) {
+        const { pallet, name, docs } = moduleError;
+        let message = `Dispatch error: ${pallet}::${name}`;
+        if (docs) {
+            message += ` - ${docs.join('\n  ')}`;
+        }
+        return message;
+    }
+    else {
+        return `Dispatch error: ${JSON.stringify(err)}`;
+    }
+};
 /**
  * Represents an error that occurred during the instantiation of a smart contract.
  * This class extends the base `DedotError` and includes a `raw` property of type `ContractInstantiateResult`.
@@ -42,16 +55,22 @@ class ContractInstantiateDispatchError extends ContractInstantiateError {
      * The error that occurred during the dispatch phase.
      */
     dispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError;
     /**
      * Constructs a new `ContractInstantiateDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract instantiation.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err, raw) {
+    constructor(err, raw, moduleError) {
         super(raw);
         this.dispatchError = err;
-        this.message = `Dispatch error: ${JSON.stringify(err)}`;
+        this.moduleError = moduleError;
+        this.message = formatDispatchError(err, moduleError);
     }
 }
 exports.ContractInstantiateDispatchError = ContractInstantiateDispatchError;
@@ -86,7 +105,7 @@ class ContractInstantiateLangError extends ContractInstantiateError {
         super(raw);
         this.langError = err;
         this.flags = (0, index_js_1.toReturnFlags)(raw.result.value.result.flags.bits);
-        this.message = `Lange error: ${JSON.stringify(err)}`;
+        this.message = `Lang error: ${JSON.stringify(err)}`;
     }
 }
 exports.ContractInstantiateLangError = ContractInstantiateLangError;
@@ -129,16 +148,22 @@ class ContractDispatchError extends ContractExecutionError {
      * The error that occurred during the dispatch phase.
      */
     dispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError;
     /**
      * Constructs a new `ContractDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract call.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err, raw) {
+    constructor(err, raw, moduleError) {
         super(raw);
         this.dispatchError = err;
-        this.message = `Dispatch error: ${JSON.stringify(err)}`;
+        this.moduleError = moduleError;
+        this.message = formatDispatchError(err, moduleError);
     }
 }
 exports.ContractDispatchError = ContractDispatchError;
@@ -173,7 +198,7 @@ class ContractLangError extends ContractExecutionError {
         super(raw);
         this.langError = err;
         this.flags = (0, index_js_1.toReturnFlags)(raw.result.value.flags.bits);
-        this.message = `Lange error: ${JSON.stringify(err)}`;
+        this.message = `Lang error: ${JSON.stringify(err)}`;
     }
 }
 exports.ContractLangError = ContractLangError;

package/cjs/executor/ConstructorQueryExecutor.js

@@ -11,8 +11,7 @@ class ConstructorQueryExecutor extends index_js_2.DeployerExecutor {
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
         const callFn = async (...params) => {
             const { args } = meta;
-            (0, utils_1.assertFalse)(params.length < args.length, `Expected at least ${args.length} arguments, got ${params.length}`);
-            (0, utils_1.assertFalse)(params.length > args.length + 1, `Expected at most ${args.length + 1} arguments, got ${params.length}`);
+            (0, index_js_1.ensureParamsLength)(args.length, params.length);
             const callOptions = (params[args.length] || {});
             const { caller = this.options.defaultCaller, // --
             value = 0n, gasLimit, storageDepositLimit, salt, } = callOptions;
@@ -64,7 +63,9 @@ class ConstructorQueryExecutor extends index_js_2.DeployerExecutor {
                 }
             })();
             if (raw.result.isErr) {
-                throw new errors_js_1.ContractInstantiateDispatchError(raw.result.err, raw);
+                const dispatchError = raw.result.err;
+                const moduleError = client.registry.findErrorMeta(dispatchError);
+                throw new errors_js_1.ContractInstantiateDispatchError(dispatchError, raw, moduleError);
             }
             const data = this.tryDecode(meta, raw.result.value.result.data);
             if (data.isErr) {

package/cjs/executor/ConstructorTxExecutor.js

@@ -2,38 +2,128 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorTxExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const index_js_1 = require("./abstract/index.js");
-class ConstructorTxExecutor extends index_js_1.DeployerExecutor {
+const Contract_js_1 = require("../Contract.js");
+const index_js_1 = require("../utils/index.js");
+const ConstructorQueryExecutor_js_1 = require("./ConstructorQueryExecutor.js");
+const index_js_2 = require("./abstract/index.js");
+class ConstructorTxExecutor extends index_js_2.DeployerExecutor {
     doExecute(constructor) {
         const meta = this.findConstructorMeta(constructor);
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
+        // @ts-ignore
         const callFn = (...params) => {
             const { args } = meta;
-            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
-            const txCallOptions = params[args.length];
+            (0, index_js_1.ensureParamsLength)(args.length, params.length);
+            const txCallOptions = (params[args.length] || {});
             const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
-            (0, utils_1.assert)(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
             const client = this.client;
-            if (this.registry.isRevive()) {
-                (0, utils_1.assert)((0, utils_1.isUndefined)(salt) || (0, utils_1.toU8a)(salt).byteLength == 32, 'Invalid salt provided in ConstructorCallOptions: expected a 32-byte value as a hex string or a Uint8Array');
-                (0, utils_1.assert)(!(0, utils_1.isUndefined)(storageDepositLimit), 'Expected a storage deposit limit in ConstructorTxOptions');
-                if ((0, utils_1.isPvm)(this.code)) {
-                    return client.tx.revive.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt ? (0, utils_1.toHex)(salt) : undefined);
+            const tx = (() => {
+                if (this.registry.isRevive()) {
+                    (0, utils_1.assert)((0, utils_1.isUndefined)(salt) || (0, utils_1.toU8a)(salt).byteLength == 32, 'Invalid salt provided in ConstructorCallOptions: expected a 32-byte value as a hex string or a Uint8Array');
+                    if ((0, utils_1.isPvm)(this.code)) {
+                        return client.tx.revive.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt ? (0, utils_1.toHex)(salt) : undefined);
+                    }
+                    else {
+                        return client.tx.revive.instantiate(value, gasLimit, storageDepositLimit, (0, utils_1.toHex)(this.code), bytes, salt ? (0, utils_1.toHex)(salt) : undefined);
+                    }
                 }
                 else {
-                    return client.tx.revive.instantiate(value, gasLimit, storageDepositLimit, (0, utils_1.toHex)(this.code), bytes, salt ? (0, utils_1.toHex)(salt) : undefined);
+                    if ((0, utils_1.isWasm)(this.code)) {
+                        return client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt || '0x');
+                    }
+                    else {
+                        return client.tx.contracts.instantiate(value, gasLimit, storageDepositLimit, (0, utils_1.toHex)(this.code), bytes, salt || '0x');
+                    }
                 }
-            }
-            else {
-                if ((0, utils_1.isWasm)(this.code)) {
-                    return client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt || '0x');
+            })();
+            let deployerAddress, deployerNonce;
+            const calculateContractAddress = async (result) => {
+                (0, utils_1.assert)(deployerAddress, 'Deployer Address Not Found');
+                const { status, events, dispatchError } = result;
+                const onChain = status.type === 'BestChainBlockIncluded' || status.type === 'Finalized';
+                (0, utils_1.assert)(onChain, 'The deployment transaction has not yet been included in the best chain block or finalized.');
+                (0, utils_1.assert)(!dispatchError, 'The deployment transaction failed to execute. Refer to the dispatch error for more information.');
+                if (this.registry.isRevive()) {
+                    if (salt) {
+                        let code;
+                        if ((0, utils_1.isPvm)(this.code)) {
+                            code = this.code;
+                        }
+                        else {
+                            // pull the raw code in case we're using a code hash here
+                            code = await client.query.revive.pristineCode((0, utils_1.toHex)(this.code));
+                        }
+                        (0, utils_1.assert)(code, 'Contract Code Binary Not Found');
+                        return (0, index_js_1.CREATE2)((0, index_js_1.toEvmAddress)(deployerAddress), // --
+                        code, bytes, salt);
+                    }
+                    else {
+                        return (0, index_js_1.CREATE1)((0, index_js_1.toEvmAddress)(deployerAddress), // --
+                        deployerNonce);
+                    }
                 }
                 else {
-                    return client.tx.contracts.instantiate(value, gasLimit, storageDepositLimit, (0, utils_1.toHex)(this.code), bytes, salt || '0x');
+                    const event = client.events.contracts.Instantiated.find(events);
+                    (0, utils_1.assert)(event, 'Contracts.Instantiated event not found');
+                    return event.palletEvent.data.contract.address();
                 }
-            }
+            };
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    deployerAddress = signerAddress;
+                    if (this.registry.isRevive() && !salt) {
+                        deployerNonce = await client.call.accountNonceApi.accountNonce(deployerAddress);
+                    }
+                    const callParams = { ...tx.call.palletCall.params };
+                    const needsDryRun = !callParams.gasLimit || (this.registry.isRevive() && !callParams.storageDepositLimit);
+                    if (!needsDryRun)
+                        return;
+                    const executor = new ConstructorQueryExecutor_js_1.ConstructorQueryExecutor(this.client, // --
+                    this.registry, this.code, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw } = await executor.doExecute(constructor)(...params);
+                    const { gasRequired, storageDeposit } = raw;
+                    if (!callParams.gasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (this.registry.isRevive() && !callParams.storageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+                transformResult: (result) => {
+                    let cachedAddress;
+                    const contractAddress = async () => {
+                        if (cachedAddress)
+                            return cachedAddress;
+                        cachedAddress = await calculateContractAddress(result);
+                        return cachedAddress;
+                    };
+                    const contract = async (overrideOptions) => {
+                        const address = await contractAddress();
+                        // Check if the contract is existed on chain or not!
+                        await (0, index_js_1.ensureContractPresence)(client, this.registry, address);
+                        return new Contract_js_1.Contract(client, // --
+                        this.metadata, address, {
+                            defaultCaller: deployerAddress,
+                            ...this.options,
+                            ...overrideOptions,
+                        });
+                    };
+                    Object.assign(result, {
+                        contractAddress,
+                        contract,
+                    });
+                    return result;
+                },
+            });
+            return tx;
         };
         callFn.meta = meta;
         return callFn;

package/cjs/executor/QueryExecutor.js

@@ -11,8 +11,7 @@ class QueryExecutor extends index_js_2.ContractExecutor {
         (0, utils_1.assert)(meta, `Query message not found: ${message}`);
         const callFn = async (...params) => {
             const { args } = meta;
-            (0, utils_1.assertFalse)(params.length < args.length, `Expected at least ${args.length} arguments, got ${params.length}`);
-            (0, utils_1.assertFalse)(params.length > args.length + 1, `Expected at most ${args.length + 1} arguments, got ${params.length}`);
+            (0, index_js_1.ensureParamsLength)(args.length, params.length);
             const callOptions = (params[args.length] || {});
             const { caller = this.options.defaultCaller, value = 0n, gasLimit, storageDepositLimit } = callOptions;
             (0, utils_1.assert)(caller, 'Expected a valid caller address in ContractCallOptions');
@@ -44,7 +43,9 @@ class QueryExecutor extends index_js_2.ContractExecutor {
                 }
             })();
             if (raw.result.isErr) {
-                throw new errors_js_1.ContractDispatchError(raw.result.err, raw);
+                const dispatchError = raw.result.err;
+                const moduleError = client.registry.findErrorMeta(dispatchError);
+                throw new errors_js_1.ContractDispatchError(dispatchError, raw, moduleError);
             }
             const data = this.tryDecode(meta, raw.result.value.data);
             if (data.isErr) {

package/cjs/executor/TxExecutor.js

@@ -2,29 +2,56 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const index_js_1 = require("./abstract/index.js");
-class TxExecutor extends index_js_1.ContractExecutor {
+const index_js_1 = require("../utils/index.js");
+const QueryExecutor_js_1 = require("./QueryExecutor.js");
+const index_js_2 = require("./abstract/index.js");
+class TxExecutor extends index_js_2.ContractExecutor {
     doExecute(message) {
         const meta = this.findTxMessage(message);
         (0, utils_1.assert)(meta, `Tx message not found: ${message}`);
         const callFn = (...params) => {
             const { args } = meta;
-            (0, utils_1.assert)(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
-            const txCallOptions = params[args.length];
+            (0, index_js_1.ensureParamsLength)(args.length, params.length);
+            const txCallOptions = (params[args.length] || {});
             const { value = 0n, gasLimit, storageDepositLimit } = txCallOptions;
-            (0, utils_1.assert)(gasLimit, 'Expected a gas limit in ContractTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = (0, utils_1.u8aToHex)((0, utils_1.concatU8a)((0, utils_1.hexToU8a)(meta.selector), ...formattedInputs));
             const client = this.client;
-            if (this.registry.isRevive()) {
-                (0, utils_1.assert)(!(0, utils_1.isUndefined)(storageDepositLimit), 'Expected a storage deposit limit in ContractTxOptions');
-                return client.tx.revive.call(this.address, // --
-                value, gasLimit, storageDepositLimit || 0n, bytes);
-            }
-            else {
-                return client.tx.contracts.call(this.address, // --
-                value, gasLimit, storageDepositLimit, bytes);
-            }
+            const tx = (() => {
+                if (this.registry.isRevive()) {
+                    return client.tx.revive.call(this.address, // --
+                    value, gasLimit, storageDepositLimit || 0n, bytes);
+                }
+                else {
+                    return client.tx.contracts.call(this.address, // --
+                    value, gasLimit, storageDepositLimit, bytes);
+                }
+            })();
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    const callParams = { ...tx.call.palletCall.params };
+                    const needsDryRun = !callParams.gasLimit || (this.registry.isRevive() && !callParams.storageDepositLimit);
+                    if (!needsDryRun)
+                        return;
+                    const executor = new QueryExecutor_js_1.QueryExecutor(this.client, // --
+                    this.registry, this.address, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw } = await executor.doExecute(message)(...params);
+                    const { gasRequired, storageDeposit } = raw;
+                    if (!callParams.gasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (this.registry.isRevive() && !callParams.storageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+            });
+            return tx;
         };
         callFn.meta = meta;
         return callFn;

package/cjs/utils/ensure.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureSupportedContractMetadataVersion = exports.ensureValidCodeHashOrCode = exports.ensureValidContractAddress = exports.ensureContractPresence = exports.ensurePalletPresence = exports.ensureStorageApiSupports = void 0;
+exports.ensureParamsLength = exports.ensureSupportedContractMetadataVersion = exports.ensureValidCodeHashOrCode = exports.ensureValidContractAddress = exports.ensureContractPresence = exports.ensurePalletPresence = exports.ensureStorageApiSupports = void 0;
 const codecs_1 = require("@dedot/codecs");
 const utils_1 = require("@dedot/utils");
 const ensureStorageApiSupports = (version) => {
@@ -66,3 +66,9 @@ function ensureSupportedContractMetadataVersion(metadata) {
     }
 }
 exports.ensureSupportedContractMetadataVersion = ensureSupportedContractMetadataVersion;
+function ensureParamsLength(expectedArgsLength, actualParamsLength) {
+    (0, utils_1.assertFalse)(actualParamsLength < expectedArgsLength, `Expected at least ${expectedArgsLength} arguments, got ${actualParamsLength}`);
+    // One extra param for the options
+    (0, utils_1.assertFalse)(actualParamsLength > expectedArgsLength + 1, `Expected at most ${expectedArgsLength + 1} arguments, got ${actualParamsLength}`);
+}
+exports.ensureParamsLength = ensureParamsLength;

package/errors.d.ts

@@ -1,4 +1,4 @@
-import { DispatchError } from '@dedot/codecs';
+import { DispatchError, PalletErrorMetadataLatest } from '@dedot/codecs';
 import { DedotError } from '@dedot/utils';
 import { ContractCallResult, ContractInstantiateResult, GenericContractApi, ReturnFlags } from './types/index.js';
 /**
@@ -36,13 +36,18 @@ export declare class ContractInstantiateDispatchError<ContractApi extends Generi
      * The error that occurred during the dispatch phase.
      */
     dispatchError: DispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError?: PalletErrorMetadataLatest;
     /**
      * Constructs a new `ContractInstantiateDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract instantiation.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err: DispatchError, raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>);
+    constructor(err: DispatchError, raw: ContractInstantiateResult<ContractApi['types']['ChainApi']>, moduleError?: PalletErrorMetadataLatest);
 }
 /**
  * Represents an error that occurred during the instantiation of a smart contract due to a language-specific error.
@@ -107,13 +112,18 @@ export declare class ContractDispatchError<ContractApi extends GenericContractAp
      * The error that occurred during the dispatch phase.
      */
     dispatchError: DispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError?: PalletErrorMetadataLatest;
     /**
      * Constructs a new `ContractDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract call.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err: DispatchError, raw: ContractCallResult<ContractApi['types']['ChainApi']>);
+    constructor(err: DispatchError, raw: ContractCallResult<ContractApi['types']['ChainApi']>, moduleError?: PalletErrorMetadataLatest);
 }
 /**
  * Represents an error that occurred during the execution of a smart contract call due to a language-specific error.

package/errors.js

@@ -1,5 +1,18 @@
 import { assert, DedotError } from '@dedot/utils';
 import { toReturnFlags } from './utils/index.js';
+const formatDispatchError = (err, moduleError) => {
+    if (moduleError) {
+        const { pallet, name, docs } = moduleError;
+        let message = `Dispatch error: ${pallet}::${name}`;
+        if (docs) {
+            message += ` - ${docs.join('\n  ')}`;
+        }
+        return message;
+    }
+    else {
+        return `Dispatch error: ${JSON.stringify(err)}`;
+    }
+};
 /**
  * Represents an error that occurred during the instantiation of a smart contract.
  * This class extends the base `DedotError` and includes a `raw` property of type `ContractInstantiateResult`.
@@ -38,16 +51,22 @@ export class ContractInstantiateDispatchError extends ContractInstantiateError {
      * The error that occurred during the dispatch phase.
      */
     dispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError;
     /**
      * Constructs a new `ContractInstantiateDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract instantiation.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err, raw) {
+    constructor(err, raw, moduleError) {
         super(raw);
         this.dispatchError = err;
-        this.message = `Dispatch error: ${JSON.stringify(err)}`;
+        this.moduleError = moduleError;
+        this.message = formatDispatchError(err, moduleError);
     }
 }
 /**
@@ -81,7 +100,7 @@ export class ContractInstantiateLangError extends ContractInstantiateError {
         super(raw);
         this.langError = err;
         this.flags = toReturnFlags(raw.result.value.result.flags.bits);
-        this.message = `Lange error: ${JSON.stringify(err)}`;
+        this.message = `Lang error: ${JSON.stringify(err)}`;
     }
 }
 /**
@@ -122,16 +141,22 @@ export class ContractDispatchError extends ContractExecutionError {
      * The error that occurred during the dispatch phase.
      */
     dispatchError;
+    /**
+     * The decoded module error, if any.
+     */
+    moduleError;
     /**
      * Constructs a new `ContractDispatchError` instance.
      *
      * @param err - The `DispatchError` that occurred during the dispatch phase.
      * @param raw - The raw result of the contract call.
+     * @param moduleError - The decoded module error, if any.
      */
-    constructor(err, raw) {
+    constructor(err, raw, moduleError) {
         super(raw);
         this.dispatchError = err;
-        this.message = `Dispatch error: ${JSON.stringify(err)}`;
+        this.moduleError = moduleError;
+        this.message = formatDispatchError(err, moduleError);
     }
 }
 /**
@@ -165,7 +190,7 @@ export class ContractLangError extends ContractExecutionError {
         super(raw);
         this.langError = err;
         this.flags = toReturnFlags(raw.result.value.flags.bits);
-        this.message = `Lange error: ${JSON.stringify(err)}`;
+        this.message = `Lang error: ${JSON.stringify(err)}`;
     }
 }
 /**

package/executor/ConstructorQueryExecutor.js

@@ -1,6 +1,6 @@
-import { assert, assertFalse, concatU8a, hexToU8a, isPvm, isUndefined, isWasm, toHex, toU8a, u8aToHex, } from '@dedot/utils';
+import { assert, concatU8a, hexToU8a, isPvm, isUndefined, isWasm, toHex, toU8a, u8aToHex } from '@dedot/utils';
 import { ContractInstantiateDispatchError, ContractInstantiateLangError } from '../errors.js';
-import { toReturnFlags } from '../utils/index.js';
+import { ensureParamsLength, toReturnFlags } from '../utils/index.js';
 import { DeployerExecutor } from './abstract/index.js';
 export class ConstructorQueryExecutor extends DeployerExecutor {
     doExecute(constructor) {
@@ -8,8 +8,7 @@ export class ConstructorQueryExecutor extends DeployerExecutor {
         assert(meta, `Constructor message not found: ${constructor}`);
         const callFn = async (...params) => {
             const { args } = meta;
-            assertFalse(params.length < args.length, `Expected at least ${args.length} arguments, got ${params.length}`);
-            assertFalse(params.length > args.length + 1, `Expected at most ${args.length + 1} arguments, got ${params.length}`);
+            ensureParamsLength(args.length, params.length);
             const callOptions = (params[args.length] || {});
             const { caller = this.options.defaultCaller, // --
             value = 0n, gasLimit, storageDepositLimit, salt, } = callOptions;
@@ -61,7 +60,9 @@ export class ConstructorQueryExecutor extends DeployerExecutor {
                 }
             })();
             if (raw.result.isErr) {
-                throw new ContractInstantiateDispatchError(raw.result.err, raw);
+                const dispatchError = raw.result.err;
+                const moduleError = client.registry.findErrorMeta(dispatchError);
+                throw new ContractInstantiateDispatchError(dispatchError, raw, moduleError);
             }
             const data = this.tryDecode(meta, raw.result.value.result.data);
             if (data.isErr) {

package/executor/ConstructorTxExecutor.js

@@ -1,36 +1,126 @@
 import { assert, concatU8a, hexToU8a, isPvm, isUndefined, isWasm, toHex, toU8a, u8aToHex } from '@dedot/utils';
+import { Contract } from '../Contract.js';
+import { CREATE1, CREATE2, ensureContractPresence, ensureParamsLength, toEvmAddress } from '../utils/index.js';
+import { ConstructorQueryExecutor } from './ConstructorQueryExecutor.js';
 import { DeployerExecutor } from './abstract/index.js';
 export class ConstructorTxExecutor extends DeployerExecutor {
     doExecute(constructor) {
         const meta = this.findConstructorMeta(constructor);
         assert(meta, `Constructor message not found: ${constructor}`);
+        // @ts-ignore
         const callFn = (...params) => {
             const { args } = meta;
-            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
-            const txCallOptions = params[args.length];
+            ensureParamsLength(args.length, params.length);
+            const txCallOptions = (params[args.length] || {});
             const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
-            assert(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             const client = this.client;
-            if (this.registry.isRevive()) {
-                assert(isUndefined(salt) || toU8a(salt).byteLength == 32, 'Invalid salt provided in ConstructorCallOptions: expected a 32-byte value as a hex string or a Uint8Array');
-                assert(!isUndefined(storageDepositLimit), 'Expected a storage deposit limit in ConstructorTxOptions');
-                if (isPvm(this.code)) {
-                    return client.tx.revive.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt ? toHex(salt) : undefined);
+            const tx = (() => {
+                if (this.registry.isRevive()) {
+                    assert(isUndefined(salt) || toU8a(salt).byteLength == 32, 'Invalid salt provided in ConstructorCallOptions: expected a 32-byte value as a hex string or a Uint8Array');
+                    if (isPvm(this.code)) {
+                        return client.tx.revive.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt ? toHex(salt) : undefined);
+                    }
+                    else {
+                        return client.tx.revive.instantiate(value, gasLimit, storageDepositLimit, toHex(this.code), bytes, salt ? toHex(salt) : undefined);
+                    }
                 }
                 else {
-                    return client.tx.revive.instantiate(value, gasLimit, storageDepositLimit, toHex(this.code), bytes, salt ? toHex(salt) : undefined);
+                    if (isWasm(this.code)) {
+                        return client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt || '0x');
+                    }
+                    else {
+                        return client.tx.contracts.instantiate(value, gasLimit, storageDepositLimit, toHex(this.code), bytes, salt || '0x');
+                    }
                 }
-            }
-            else {
-                if (isWasm(this.code)) {
-                    return client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt || '0x');
+            })();
+            let deployerAddress, deployerNonce;
+            const calculateContractAddress = async (result) => {
+                assert(deployerAddress, 'Deployer Address Not Found');
+                const { status, events, dispatchError } = result;
+                const onChain = status.type === 'BestChainBlockIncluded' || status.type === 'Finalized';
+                assert(onChain, 'The deployment transaction has not yet been included in the best chain block or finalized.');
+                assert(!dispatchError, 'The deployment transaction failed to execute. Refer to the dispatch error for more information.');
+                if (this.registry.isRevive()) {
+                    if (salt) {
+                        let code;
+                        if (isPvm(this.code)) {
+                            code = this.code;
+                        }
+                        else {
+                            // pull the raw code in case we're using a code hash here
+                            code = await client.query.revive.pristineCode(toHex(this.code));
+                        }
+                        assert(code, 'Contract Code Binary Not Found');
+                        return CREATE2(toEvmAddress(deployerAddress), // --
+                        code, bytes, salt);
+                    }
+                    else {
+                        return CREATE1(toEvmAddress(deployerAddress), // --
+                        deployerNonce);
+                    }
                 }
                 else {
-                    return client.tx.contracts.instantiate(value, gasLimit, storageDepositLimit, toHex(this.code), bytes, salt || '0x');
+                    const event = client.events.contracts.Instantiated.find(events);
+                    assert(event, 'Contracts.Instantiated event not found');
+                    return event.palletEvent.data.contract.address();
                 }
-            }
+            };
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    deployerAddress = signerAddress;
+                    if (this.registry.isRevive() && !salt) {
+                        deployerNonce = await client.call.accountNonceApi.accountNonce(deployerAddress);
+                    }
+                    const callParams = { ...tx.call.palletCall.params };
+                    const needsDryRun = !callParams.gasLimit || (this.registry.isRevive() && !callParams.storageDepositLimit);
+                    if (!needsDryRun)
+                        return;
+                    const executor = new ConstructorQueryExecutor(this.client, // --
+                    this.registry, this.code, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw } = await executor.doExecute(constructor)(...params);
+                    const { gasRequired, storageDeposit } = raw;
+                    if (!callParams.gasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (this.registry.isRevive() && !callParams.storageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+                transformResult: (result) => {
+                    let cachedAddress;
+                    const contractAddress = async () => {
+                        if (cachedAddress)
+                            return cachedAddress;
+                        cachedAddress = await calculateContractAddress(result);
+                        return cachedAddress;
+                    };
+                    const contract = async (overrideOptions) => {
+                        const address = await contractAddress();
+                        // Check if the contract is existed on chain or not!
+                        await ensureContractPresence(client, this.registry, address);
+                        return new Contract(client, // --
+                        this.metadata, address, {
+                            defaultCaller: deployerAddress,
+                            ...this.options,
+                            ...overrideOptions,
+                        });
+                    };
+                    Object.assign(result, {
+                        contractAddress,
+                        contract,
+                    });
+                    return result;
+                },
+            });
+            return tx;
         };
         callFn.meta = meta;
         return callFn;

package/executor/QueryExecutor.js

@@ -1,6 +1,6 @@
-import { assert, assertFalse, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
+import { assert, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
 import { ContractDispatchError, ContractLangError } from '../errors.js';
-import { ensureContractPresence, toReturnFlags } from '../utils/index.js';
+import { ensureContractPresence, ensureParamsLength, toReturnFlags } from '../utils/index.js';
 import { ContractExecutor } from './abstract/index.js';
 export class QueryExecutor extends ContractExecutor {
     doExecute(message) {
@@ -8,8 +8,7 @@ export class QueryExecutor extends ContractExecutor {
         assert(meta, `Query message not found: ${message}`);
         const callFn = async (...params) => {
             const { args } = meta;
-            assertFalse(params.length < args.length, `Expected at least ${args.length} arguments, got ${params.length}`);
-            assertFalse(params.length > args.length + 1, `Expected at most ${args.length + 1} arguments, got ${params.length}`);
+            ensureParamsLength(args.length, params.length);
             const callOptions = (params[args.length] || {});
             const { caller = this.options.defaultCaller, value = 0n, gasLimit, storageDepositLimit } = callOptions;
             assert(caller, 'Expected a valid caller address in ContractCallOptions');
@@ -41,7 +40,9 @@ export class QueryExecutor extends ContractExecutor {
                 }
             })();
             if (raw.result.isErr) {
-                throw new ContractDispatchError(raw.result.err, raw);
+                const dispatchError = raw.result.err;
+                const moduleError = client.registry.findErrorMeta(dispatchError);
+                throw new ContractDispatchError(dispatchError, raw, moduleError);
             }
             const data = this.tryDecode(meta, raw.result.value.data);
             if (data.isErr) {

package/executor/TxExecutor.js

@@ -1,4 +1,6 @@
-import { assert, concatU8a, hexToU8a, isUndefined, u8aToHex } from '@dedot/utils';
+import { assert, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
+import { ensureParamsLength } from '../utils/index.js';
+import { QueryExecutor } from './QueryExecutor.js';
 import { ContractExecutor } from './abstract/index.js';
 export class TxExecutor extends ContractExecutor {
     doExecute(message) {
@@ -6,22 +8,47 @@ export class TxExecutor extends ContractExecutor {
         assert(meta, `Tx message not found: ${message}`);
         const callFn = (...params) => {
             const { args } = meta;
-            assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
-            const txCallOptions = params[args.length];
+            ensureParamsLength(args.length, params.length);
+            const txCallOptions = (params[args.length] || {});
             const { value = 0n, gasLimit, storageDepositLimit } = txCallOptions;
-            assert(gasLimit, 'Expected a gas limit in ContractTxOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
             const client = this.client;
-            if (this.registry.isRevive()) {
-                assert(!isUndefined(storageDepositLimit), 'Expected a storage deposit limit in ContractTxOptions');
-                return client.tx.revive.call(this.address, // --
-                value, gasLimit, storageDepositLimit || 0n, bytes);
-            }
-            else {
-                return client.tx.contracts.call(this.address, // --
-                value, gasLimit, storageDepositLimit, bytes);
-            }
+            const tx = (() => {
+                if (this.registry.isRevive()) {
+                    return client.tx.revive.call(this.address, // --
+                    value, gasLimit, storageDepositLimit || 0n, bytes);
+                }
+                else {
+                    return client.tx.contracts.call(this.address, // --
+                    value, gasLimit, storageDepositLimit, bytes);
+                }
+            })();
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    const callParams = { ...tx.call.palletCall.params };
+                    const needsDryRun = !callParams.gasLimit || (this.registry.isRevive() && !callParams.storageDepositLimit);
+                    if (!needsDryRun)
+                        return;
+                    const executor = new QueryExecutor(this.client, // --
+                    this.registry, this.address, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw } = await executor.doExecute(message)(...params);
+                    const { gasRequired, storageDeposit } = raw;
+                    if (!callParams.gasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (this.registry.isRevive() && !callParams.storageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+            });
+            return tx;
         };
         callFn.meta = meta;
         return callFn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.13.2",
+  "version": "0.14.0",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -18,10 +18,10 @@
     "test": "npx vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.13.2",
-    "@dedot/codecs": "0.13.2",
-    "@dedot/types": "0.13.2",
-    "@dedot/utils": "0.13.2",
+    "@dedot/api": "0.14.0",
+    "@dedot/codecs": "0.14.0",
+    "@dedot/types": "0.14.0",
+    "@dedot/utils": "0.14.0",
     "@ethereumjs/rlp": "^10.0.0"
   },
   "publishConfig": {
@@ -32,7 +32,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "2835a0995d758ac3bcdfe1f880eb6e8d9b1e5605",
+  "gitHead": "cde1e77566038990fcdd69b291a4231013c16528",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/types/index.d.ts

@@ -1,6 +1,7 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
 import { AccountId32Like, type Bytes, BytesLike, type DispatchError, Extrinsic, type H256, type Result, Weight } from '@dedot/codecs';
-import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, ISubmittableResult, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import { Contract } from '../Contract.js';
 import { ContractAddress, ContractCallMessage, ContractConstructorMessage } from './shared.js';
 import { ContractEventV4, ContractMetadataV4 } from './v4.js';
 import { ContractEventV5, ContractMetadataV5 } from './v5.js';
@@ -69,9 +70,19 @@ export type ContractInstantiateResult<_ extends GenericSubstrateApi> = {
     debugMessage?: Bytes;
     result: Result<InstantiateReturnValue, DispatchError>;
 };
-type SubmittableExtrinsic = ISubmittableExtrinsic & Extrinsic;
-export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic;
-export type GenericInstantiateSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic;
+interface IContractInstantiateSubmittableResult<ContractApi extends GenericContractApi = GenericContractApi> extends ISubmittableResult {
+    /**
+     * Get deployed contract address
+     */
+    contractAddress(): Promise<ContractAddress>;
+    /**
+     * Get deployed contract instance
+     */
+    contract(options?: ExecutionOptions): Promise<Contract<ContractApi>>;
+}
+type SubmittableExtrinsic<R extends ISubmittableResult> = ISubmittableExtrinsic<R> & Extrinsic;
+export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic<ISubmittableResult>;
+export type GenericInstantiateSubmittableExtrinsic<_ extends GenericSubstrateApi, ContractApi extends GenericContractApi = GenericContractApi> = SubmittableExtrinsic<IContractInstantiateSubmittableResult<ContractApi>>;
 export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5 | ContractMetadataV6;
 export interface LooseContractMetadata {
     version: number | string;
@@ -88,14 +99,11 @@ export type ConstructorCallOptions = CallOptions & {
 };
 export type ConstructorTxOptions = CallOptions & {
     salt?: BytesLike;
-    gasLimit: Weight;
 };
 export type ContractCallOptions = CallOptions & {
     caller?: AccountId32Like;
 };
-export type ContractTxOptions = CallOptions & {
-    gasLimit: Weight;
-};
+export type ContractTxOptions = CallOptions;
 export type GenericContractQueryCall<ChainApi extends GenericSubstrateApi, F extends AsyncMethod = (...args: any[]) => Promise<GenericContractCallResult<any, ContractCallResult<ChainApi>>>> = F & {
     meta: ContractCallMessage;
 };

package/types/v6.d.ts

@@ -1,4 +1,4 @@
-import { ContractInformation, ContractSource, ContractType } from './shared';
+import { ContractInformation, ContractSource, ContractType } from './shared.js';
 import { ContractSpecV5, ContractStorageV5 } from './v5.js';
 export interface ContractSourceV6 extends ContractSource {
     contract_binary?: string;

package/utils/ensure.d.ts

@@ -10,3 +10,4 @@ export declare function ensureContractPresence(client: ISubstrateClient<Substrat
 export declare function ensureValidContractAddress(address: ContractAddress, registry: TypinkRegistry): void;
 export declare function ensureValidCodeHashOrCode(codeHashOrCode: Hash | Uint8Array | string, registry: TypinkRegistry): void;
 export declare function ensureSupportedContractMetadataVersion(metadata: LooseContractMetadata): void;
+export declare function ensureParamsLength(expectedArgsLength: number, actualParamsLength: number): void;

package/utils/ensure.js

@@ -1,5 +1,5 @@
 import { accountId32ToHex } from '@dedot/codecs';
-import { assert, DedotError, ensurePresence, hexToU8a, isEvmAddress, isPvm, isWasm, toU8a, } from '@dedot/utils';
+import { assert, assertFalse, DedotError, ensurePresence, hexToU8a, isEvmAddress, isPvm, isWasm, toU8a, } from '@dedot/utils';
 export const ensureStorageApiSupports = (version) => {
     const numberedVersion = typeof version === 'number' ? version : parseInt(version);
     assert(numberedVersion >= 5, `Contract Storage Api Only Available for metadata version >= 5, current version: ${version}`);
@@ -57,3 +57,8 @@ export function ensureSupportedContractMetadataVersion(metadata) {
         throw new DedotError(`Unsupported metadata version: ${metadata.version}`);
     }
 }
+export function ensureParamsLength(expectedArgsLength, actualParamsLength) {
+    assertFalse(actualParamsLength < expectedArgsLength, `Expected at least ${expectedArgsLength} arguments, got ${actualParamsLength}`);
+    // One extra param for the options
+    assertFalse(actualParamsLength > expectedArgsLength + 1, `Expected at most ${expectedArgsLength + 1} arguments, got ${actualParamsLength}`);
+}