@dedot/contracts 0.17.0 → 0.17.1-next.db98ff20.1

package/cjs/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 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;
+exports.isSolContractInstantiateError = exports.isSolContractExecutionError = exports.isContractInstantiateLangError = exports.isContractInstantiateDispatchError = exports.isContractInstantiateError = exports.isContractLangError = exports.isContractDispatchError = exports.isContractExecutionError = exports.SolContractExecutionError = exports.SolContractInstantiateError = 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) => {
@@ -202,6 +202,52 @@ class ContractLangError extends ContractExecutionError {
     }
 }
 exports.ContractLangError = ContractLangError;
+/**
+ * Represents a custom error that occurred during the instantiation of a solidity smart contract.
+ * This class extends `ContractInstantiateError` and includes properties for the error name and description.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `SolGenericContractApi`.
+ *
+ * @extends ContractInstantiateError
+ */
+class SolContractInstantiateError extends ContractInstantiateError {
+    name = 'SolContractInstantiateError';
+    details;
+    constructor(raw, { details, message }) {
+        super(raw);
+        this.details = details;
+        if (message) {
+            this.message = message;
+        }
+        else if (details) {
+            this.message = `Error: ${details.errorName}`;
+        }
+    }
+}
+exports.SolContractInstantiateError = SolContractInstantiateError;
+/**
+ * Represents a custom error that occurred during the execution of a smart contract call.
+ * This class extends `ContractExecutionError` and includes properties for the error name and description.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `SolGenericContractApi`.
+ *
+ * @extends ContractExecutionError
+ */
+class SolContractExecutionError extends ContractExecutionError {
+    name = 'SolContractExecutionError';
+    details;
+    constructor(raw, { details, message }) {
+        super(raw);
+        this.details = details;
+        if (message) {
+            this.message = message;
+        }
+        else if (details) {
+            this.message = `Error: ${details.errorName}`;
+        }
+    }
+}
+exports.SolContractExecutionError = SolContractExecutionError;
 /**
  * Checks if the provided error is an instance of `ContractExecutionError`.
  *
@@ -297,3 +343,31 @@ function isContractInstantiateLangError(e) {
     return e instanceof ContractInstantiateLangError;
 }
 exports.isContractInstantiateLangError = isContractInstantiateLangError;
+/**
+ * Checks if the provided error is an instance of `isSolContractExecutionError`.
+ * This function is used to determine if a given error is a custom error specific to a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `SolGenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `isSolContractExecutionError`, `false` otherwise.
+ */
+function isSolContractExecutionError(e) {
+    return e instanceof SolContractExecutionError;
+}
+exports.isSolContractExecutionError = isSolContractExecutionError;
+/**
+ * Checks if the provided error is an instance of `SolContractInstantiateError`.
+ * This function is used to determine if a given error is a custom error specific to the instantiation of a smart contract.
+ *
+ * @template ContractApi - The type of the contract API. Defaults to `SolGenericContractApi`.
+ *
+ * @param e - The error to be checked. This should be an instance of `Error`.
+ *
+ * @returns `true` if the error is an instance of `SolContractInstantiateError`, `false` otherwise.
+ */
+function isSolContractInstantiateError(e) {
+    return e instanceof SolContractInstantiateError;
+}
+exports.isSolContractInstantiateError = isSolContractInstantiateError;

package/cjs/executor/index.js

@@ -14,8 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./abstract/index.js"), exports);
-__exportStar(require("./TxExecutor.js"), exports);
-__exportStar(require("./QueryExecutor.js"), exports);
-__exportStar(require("./ConstructorTxExecutor.js"), exports);
-__exportStar(require("./EventExecutor.js"), exports);
+__exportStar(require("./ink/index.js"), exports);
+__exportStar(require("./sol/index.js"), exports);

package/cjs/executor/{ConstructorQueryExecutor.js → ink/ConstructorQueryExecutor.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorQueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const errors_js_1 = require("../errors.js");
-const index_js_1 = require("../utils/index.js");
+const errors_js_1 = require("../../errors.js");
+const index_js_1 = require("../../utils/index.js");
 const index_js_2 = require("./abstract/index.js");
 class ConstructorQueryExecutor extends index_js_2.DeployerExecutor {
     doExecute(constructor) {
@@ -16,6 +16,7 @@ class ConstructorQueryExecutor extends index_js_2.DeployerExecutor {
             const { caller = this.options.defaultCaller, // --
             value = 0n, gasLimit, storageDepositLimit, salt, } = callOptions;
             (0, utils_1.assert)(caller, 'Expected a valid caller address in ConstructorCallOptions');
+            (0, index_js_1.ensureValidAccountId32Address)(caller);
             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 isUpload = (0, utils_1.isPvm)(this.code) || (0, utils_1.isWasm)(this.code);

package/cjs/executor/{ConstructorTxExecutor.js → ink/ConstructorTxExecutor.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorTxExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const Contract_js_1 = require("../Contract.js");
-const index_js_1 = require("../utils/index.js");
+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 {
@@ -108,8 +108,9 @@ class ConstructorTxExecutor extends index_js_2.DeployerExecutor {
                     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);
+                        await (0, index_js_1.ensureContractPresence)(client, this.registry.isRevive(), address);
                         return new Contract_js_1.Contract(client, // --
+                        // @ts-ignore
                         this.metadata, address, {
                             defaultCaller: deployerAddress,
                             ...this.options,

package/cjs/executor/{QueryExecutor.js → ink/QueryExecutor.js}

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const errors_js_1 = require("../errors.js");
-const index_js_1 = require("../utils/index.js");
+const errors_js_1 = require("../../errors.js");
+const index_js_1 = require("../../utils/index.js");
 const index_js_2 = require("./abstract/index.js");
 class QueryExecutor extends index_js_2.ContractExecutor {
     doExecute(message) {
@@ -15,10 +15,11 @@ class QueryExecutor extends index_js_2.ContractExecutor {
             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');
+            (0, index_js_1.ensureValidAccountId32Address)(caller);
             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;
-            await (0, index_js_1.ensureContractPresence)(client, this.registry, this.address);
+            await (0, index_js_1.ensureContractPresence)(client, this.registry.isRevive(), this.address, this.registry.cache);
             const raw = await (async () => {
                 if (this.registry.isRevive()) {
                     const raw = await client.call.reviveApi.call(caller, // --

package/cjs/executor/{TxExecutor.js → ink/TxExecutor.js}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TxExecutor = void 0;
 const utils_1 = require("@dedot/utils");
-const index_js_1 = require("../utils/index.js");
+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 {

package/cjs/executor/{abstract → ink/abstract}/ContractExecutor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractExecutor = void 0;
-const index_js_1 = require("../../utils/index.js");
+const index_js_1 = require("../../../utils/index.js");
 const Executor_js_1 = require("./Executor.js");
 class ContractExecutor extends Executor_js_1.Executor {
     address;

package/cjs/executor/{abstract → ink/abstract}/DeployerExecutor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployerExecutor = void 0;
-const index_js_1 = require("../../utils/index.js");
+const index_js_1 = require("../../../utils/index.js");
 const Executor_js_1 = require("./Executor.js");
 class DeployerExecutor extends Executor_js_1.Executor {
     code;

package/cjs/executor/ink/index.js

@@ -0,0 +1,22 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./abstract/index.js"), exports);
+__exportStar(require("./TxExecutor.js"), exports);
+__exportStar(require("./QueryExecutor.js"), exports);
+__exportStar(require("./ConstructorTxExecutor.js"), exports);
+__exportStar(require("./ConstructorQueryExecutor.js"), exports);
+__exportStar(require("./EventExecutor.js"), exports);

package/cjs/executor/sol/SolConstructorQueryExecutor.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolConstructorQueryExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("viem/utils");
+const errors_js_1 = require("../../errors.js");
+const index_js_1 = require("../../utils/index.js");
+const index_js_2 = require("./abstract/index.js");
+class SolConstructorQueryExecutor extends index_js_2.SolDeployerExecutor {
+    doExecute(_) {
+        const abiConstructor = this.registry.findAbiConstructor();
+        const callFn = async (...params) => {
+            const { inputs } = abiConstructor;
+            (0, index_js_1.ensureParamsLength)(inputs.length, params.length);
+            const callOptions = (params[inputs.length] || {});
+            const { caller = this.options.defaultCaller, // --
+            value = 0n, gasLimit, storageDepositLimit, salt, } = callOptions;
+            (0, utils_1.assert)(caller, 'Expected a valid caller address in ConstructorCallOptions');
+            (0, index_js_1.ensureValidAccountId32Address)(caller);
+            (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');
+            const bytes = (0, utils_2.encodeDeployData)({
+                abi: this.abi,
+                bytecode: '0x',
+                args: params.slice(0, inputs.length),
+            });
+            const isUpload = (0, utils_1.isPvm)(this.code);
+            const code = {
+                type: isUpload ? 'Upload' : 'Existing',
+                value: this.code,
+            };
+            const client = this.client;
+            const raw = await (async () => {
+                const raw = await client.call.reviveApi.instantiate(caller, // --
+                value, gasLimit, storageDepositLimit, code, bytes, salt ? (0, utils_1.toHex)(salt) : undefined);
+                const result = raw.result;
+                if (result.isOk) {
+                    // @ts-ignore
+                    result.value.address = result.value.addr;
+                    // @ts-ignore
+                    delete result.value.addr;
+                }
+                return {
+                    gasConsumed: raw.gasConsumed,
+                    gasRequired: raw.gasRequired,
+                    storageDeposit: raw.storageDeposit,
+                    result,
+                };
+            })();
+            if (raw.result.isErr) {
+                const moduleError = client.registry.findErrorMeta(raw.result.err);
+                throw new errors_js_1.ContractInstantiateDispatchError(raw.result.err, raw, moduleError);
+            }
+            const flags = (0, index_js_1.toReturnFlags)(raw.result.value.result.flags.bits);
+            const data = raw.result.value.result.data;
+            if (flags.revert) {
+                let errorResult;
+                try {
+                    errorResult = (0, utils_2.decodeErrorResult)({
+                        abi: this.abi,
+                        data,
+                    });
+                }
+                catch (e) {
+                    // TODO make this better, handle panic!, assert! cases
+                    throw new errors_js_1.SolContractInstantiateError(raw, { message: `Failed to decode error. Details: ${e.message}` });
+                }
+                throw new errors_js_1.SolContractInstantiateError(raw, { details: errorResult });
+            }
+            return {
+                data: [],
+                raw,
+                flags,
+                address: raw.result.value.address,
+                inputData: bytes,
+            };
+        };
+        callFn.meta = abiConstructor;
+        return callFn;
+    }
+}
+exports.SolConstructorQueryExecutor = SolConstructorQueryExecutor;

package/cjs/executor/sol/SolConstructorTxExecutor.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolConstructorTxExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("viem/utils");
+const Contract_js_1 = require("../../Contract.js");
+const index_js_1 = require("../../utils/index.js");
+const SolConstructorQueryExecutor_js_1 = require("./SolConstructorQueryExecutor.js");
+const index_js_2 = require("./abstract/index.js");
+class SolConstructorTxExecutor extends index_js_2.SolDeployerExecutor {
+    doExecute(_) {
+        const abiConstructor = this.registry.findAbiConstructor();
+        // @ts-ignore
+        const callFn = (...params) => {
+            const { inputs } = abiConstructor;
+            (0, index_js_1.ensureParamsLength)(inputs.length, params.length);
+            const txCallOptions = (params[inputs.length] || {});
+            const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
+            (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');
+            const bytes = (0, utils_2.encodeDeployData)({
+                abi: this.abi,
+                bytecode: '0x',
+                args: params.slice(0, inputs.length),
+            });
+            const client = this.client;
+            const tx = (() => {
+                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);
+                }
+            })();
+            let deployerAddress, deployerNonce;
+            const calculateContractAddress = async (result) => {
+                (0, utils_1.assert)(deployerAddress, 'Deployer address Not Found');
+                const { status, 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 (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);
+                }
+            };
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    // Set data for next hooks
+                    deployerAddress = signerAddress;
+                    if (!salt) {
+                        deployerNonce = await client.call.accountNonceApi.accountNonce(deployerAddress);
+                    }
+                    const callParams = { ...tx.call.palletCall.params };
+                    const hasGasLimit = !!callParams.gasLimit;
+                    const hasStorageDepositLimit = !!callParams.storageDepositLimit;
+                    // Check if current tx provide gas limit and storage deposit limit
+                    // If not, we need to do a dry run to get the actual value
+                    const needsDryRun = !hasGasLimit || !hasStorageDepositLimit;
+                    if (!needsDryRun)
+                        return;
+                    const executor = new SolConstructorQueryExecutor_js_1.SolConstructorQueryExecutor(this.client, // --
+                    this.registry, this.code, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw: { gasRequired, storageDeposit }, } = await executor.doExecute('new')(...params);
+                    // Replace the params with gas limit and storage deposit limit
+                    if (!hasGasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (!hasStorageDepositLimit) {
+                        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, true, address);
+                        return new Contract_js_1.Contract(client, // --
+                        this.abi, address, {
+                            defaultCaller: deployerAddress,
+                            ...this.options,
+                            ...overrideOptions,
+                        });
+                    };
+                    Object.assign(result, {
+                        contractAddress,
+                        contract,
+                    });
+                    return result;
+                },
+            });
+            return tx;
+        };
+        callFn.meta = abiConstructor;
+        return callFn;
+    }
+}
+exports.SolConstructorTxExecutor = SolConstructorTxExecutor;

package/cjs/executor/sol/SolEventExecutor.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolEventExecutor = void 0;
+const api_1 = require("@dedot/api");
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("./abstract/index.js");
+class SolEventExecutor extends index_js_1.SolContractExecutor {
+    doExecute(eventName) {
+        const abiEvent = this.registry.findAbiEvent(eventName);
+        (0, utils_1.assert)(abiEvent, `Abi item not found: ${eventName}`);
+        const is = (event) => {
+            if ((0, api_1.isEventRecord)(event)) {
+                try {
+                    event = this.registry.decodeEvent(event, this.address);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return event.name === eventName;
+        };
+        const find = (events) => {
+            if (!events || events.length === 0)
+                return undefined;
+            if ((0, api_1.isEventRecord)(events[0])) {
+                return this.registry.decodeEvents(events, this.address).find(is);
+            }
+            else {
+                return events.find(is);
+            }
+        };
+        const filter = (events) => {
+            if ((0, api_1.isEventRecord)(events[0])) {
+                return this.registry.decodeEvents(events, this.address).filter(is);
+            }
+            else {
+                return events.filter(is);
+            }
+        };
+        const watch = (callback) => {
+            return this.client.query.system.events((records) => {
+                const events = filter(records);
+                if (events.length === 0)
+                    return;
+                callback(filter(records));
+            });
+        };
+        return {
+            is,
+            find,
+            filter,
+            meta: abiEvent,
+            watch,
+        };
+    }
+}
+exports.SolEventExecutor = SolEventExecutor;

package/cjs/executor/sol/SolQueryExecutor.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolQueryExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("viem/utils");
+const errors_js_1 = require("../../errors.js");
+const index_js_1 = require("../../utils/index.js");
+const SolContractExecutor_js_1 = require("./abstract/SolContractExecutor.js");
+class SolQueryExecutor extends SolContractExecutor_js_1.SolContractExecutor {
+    doExecute(name) {
+        const abiFunction = this.registry.findAbiFunction(name);
+        (0, utils_1.assert)(abiFunction, `Abi item not found: ${name}`);
+        const callFn = async (...params) => {
+            const { inputs } = abiFunction;
+            (0, index_js_1.ensureParamsLength)(inputs.length, params.length);
+            const callOptions = (params[inputs.length] || {});
+            const { caller = this.options.defaultCaller, value = 0n, gasLimit, storageDepositLimit } = callOptions;
+            (0, utils_1.assert)(caller, 'Expected a valid caller address in ContractCallOptions');
+            (0, index_js_1.ensureValidAccountId32Address)(caller);
+            const bytes = (0, utils_2.encodeFunctionData)({
+                abi: this.abi,
+                functionName: abiFunction.name,
+                args: params.slice(0, inputs.length),
+            });
+            const client = this.client;
+            await (0, index_js_1.ensureContractPresence)(client, true, this.address, this.registry.cache);
+            const raw = await (async () => {
+                const raw = await client.call.reviveApi.call(caller, // --
+                this.address, value, gasLimit, storageDepositLimit, bytes);
+                return {
+                    gasConsumed: raw.gasConsumed,
+                    gasRequired: raw.gasRequired,
+                    storageDeposit: raw.storageDeposit,
+                    result: raw.result,
+                };
+            })();
+            if (raw.result.isErr) {
+                const moduleError = client.registry.findErrorMeta(raw.result.err);
+                throw new errors_js_1.ContractDispatchError(raw.result.err, raw, moduleError);
+            }
+            const flags = (0, index_js_1.toReturnFlags)(raw.result.value.flags.bits);
+            const data = raw.result.value.data;
+            if (flags.revert) {
+                let errorResult;
+                try {
+                    errorResult = (0, utils_2.decodeErrorResult)({
+                        abi: this.abi,
+                        data,
+                    });
+                }
+                catch (e) {
+                    // TODO make this better, handle panic!, assert! cases
+                    throw new errors_js_1.SolContractExecutionError(raw, { message: `Failed to decode error. Details: ${e.message}` });
+                }
+                throw new errors_js_1.SolContractExecutionError(raw, { details: errorResult });
+            }
+            try {
+                let decodedData = (0, utils_2.decodeFunctionResult)({
+                    abi: this.abi,
+                    functionName: abiFunction.name,
+                    data,
+                });
+                // if this is a tx, then this is a dry run, so the data will be default to []
+                const isTx = abiFunction.stateMutability === 'payable' || abiFunction.stateMutability === 'nonpayable';
+                if (isTx && data === '0x' && decodedData === undefined) {
+                    decodedData = [];
+                }
+                return {
+                    data: decodedData,
+                    raw,
+                    flags,
+                    inputData: bytes,
+                };
+            }
+            catch (e) {
+                throw new errors_js_1.SolContractExecutionError(raw, { message: `Failed to decode result. Details: ${e.message}` });
+            }
+        };
+        callFn.meta = abiFunction;
+        return callFn;
+    }
+}
+exports.SolQueryExecutor = SolQueryExecutor;

package/cjs/executor/sol/SolTxExecutor.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolTxExecutor = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("viem/utils");
+const index_js_1 = require("../../utils/index.js");
+const SolQueryExecutor_js_1 = require("./SolQueryExecutor.js");
+const SolContractExecutor_js_1 = require("./abstract/SolContractExecutor.js");
+class SolTxExecutor extends SolContractExecutor_js_1.SolContractExecutor {
+    doExecute(name) {
+        const txAbiFunction = this.registry.findTxAbiFunction(name);
+        (0, utils_1.assert)(txAbiFunction, `Abi item not found: ${name}`);
+        const callFn = (...params) => {
+            const { inputs } = txAbiFunction;
+            (0, index_js_1.ensureParamsLength)(inputs.length, params.length);
+            const txCallOptions = (params[inputs.length] || {});
+            const { value = 0n, gasLimit, storageDepositLimit } = txCallOptions;
+            const bytes = (0, utils_2.encodeFunctionData)({
+                abi: this.abi,
+                functionName: txAbiFunction.name,
+                args: params.slice(0, inputs.length),
+            });
+            const client = this.client;
+            const tx = (() => {
+                return client.tx.revive.call(this.address, // --
+                value, gasLimit, storageDepositLimit || 0n, bytes);
+            })();
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    const callParams = { ...tx.call.palletCall.params };
+                    const hasGasLimit = !!callParams.gasLimit;
+                    const hasStorageDepositLimit = !!callParams.storageDepositLimit;
+                    // Check if current tx provide gas limit and storage deposit limit
+                    // If not, we need to do a dry run to get the actual value
+                    const needsDryRun = !hasGasLimit || !hasStorageDepositLimit;
+                    if (!needsDryRun)
+                        return;
+                    const executor = new SolQueryExecutor_js_1.SolQueryExecutor(this.client, // --
+                    this.registry, this.address, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw } = await executor.doExecute(name)(...params);
+                    const { gasRequired, storageDeposit } = raw;
+                    if (!callParams.gasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (!callParams.storageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+            });
+            return tx;
+        };
+        callFn.meta = txAbiFunction;
+        return callFn;
+    }
+}
+exports.SolTxExecutor = SolTxExecutor;

package/cjs/executor/sol/abstract/SolContractExecutor.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolContractExecutor = void 0;
+const SolExecutor_js_1 = require("./SolExecutor.js");
+class SolContractExecutor extends SolExecutor_js_1.SolExecutor {
+    address;
+    constructor(client, registry, address, options) {
+        super(client, registry, options);
+        this.address = address;
+    }
+}
+exports.SolContractExecutor = SolContractExecutor;

package/cjs/executor/sol/abstract/SolDeployerExecutor.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolDeployerExecutor = void 0;
+const SolExecutor_js_1 = require("./SolExecutor.js");
+class SolDeployerExecutor extends SolExecutor_js_1.SolExecutor {
+    code;
+    constructor(client, registry, code, options) {
+        super(client, registry, options);
+        this.code = code;
+    }
+}
+exports.SolDeployerExecutor = SolDeployerExecutor;