@dedot/contracts 0.12.1-next.c7fd0a6c.2 → 0.13.0

package/cjs/types/index.js

@@ -15,3 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./shared.js"), exports);
+__exportStar(require("./v4.js"), exports);
+__exportStar(require("./v5.js"), exports);
+__exportStar(require("./v6.js"), exports);

package/cjs/types/v6.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/utils/address.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toEvmAddress = exports.CREATE2 = exports.CREATE1 = void 0;
+const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
+const rlp_1 = require("@ethereumjs/rlp");
+/**
+ * Calculate new contract's address is based on the deployer's address and a nonce
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L197-L204
+ *
+ * @param deployer
+ * @param nonce
+ */
+function CREATE1(deployer, nonce) {
+    const encodedData = rlp_1.RLP.encode([new codecs_1.AccountId20(deployer).raw, (0, utils_1.toHex)(nonce)]);
+    const hash = (0, utils_1.keccakAsU8a)(encodedData);
+    return (0, utils_1.u8aToHex)(hash.subarray(12));
+}
+exports.CREATE1 = CREATE1;
+/**
+ * Calculate contract's address deterministically based on the salt, deployer's address, and the code & input data.
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L206-L219
+ *
+ * @param deployer
+ * @param code
+ * @param inputData Input data for the constructor call
+ * @param salt Salt for the deployment
+ */
+function CREATE2(deployer, code, inputData, salt) {
+    const initCodeHash = (0, utils_1.keccakAsU8a)((0, utils_1.concatU8a)((0, utils_1.toU8a)(code), (0, utils_1.toU8a)(inputData)));
+    const bytes = new Uint8Array(1 + (20 + 32 + 32)); // 0xff + deployer + salt + initCodeHash
+    bytes[0] = 0xff;
+    bytes.set((0, utils_1.hexToU8a)(new codecs_1.AccountId20(deployer).raw), 1);
+    bytes.set((0, utils_1.toU8a)(salt), 21);
+    bytes.set(initCodeHash, 53);
+    return (0, utils_1.u8aToHex)((0, utils_1.keccakAsU8a)(bytes).subarray(12));
+}
+exports.CREATE2 = CREATE2;
+function isEthDerived(accountId) {
+    if (accountId.length >= 32) {
+        return accountId.slice(20, accountId.length).every((byte) => byte === 0xee);
+    }
+    return false;
+}
+/**
+ * Convert a substrate address (H256) to an evm address (H160)
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L101-L113
+ *
+ * @param accountId
+ */
+function toEvmAddress(accountId) {
+    const accountBytes = (0, utils_1.hexToU8a)(new codecs_1.AccountId32(accountId).raw);
+    const accountBuffer = new Uint8Array(32);
+    accountBuffer.set(accountBytes.slice(0, 32));
+    if (isEthDerived(accountBytes)) {
+        // This was originally an eth address
+        // We just strip the 0xEE suffix to get the original address
+        return ('0x' + Buffer.from(accountBuffer.slice(0, 20)).toString('hex'));
+    }
+    else {
+        return (0, utils_1.u8aToHex)((0, utils_1.keccakAsU8a)(accountBuffer).subarray(12));
+    }
+}
+exports.toEvmAddress = toEvmAddress;

package/cjs/utils/ensure.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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) => {
+    const numberedVersion = typeof version === 'number' ? version : parseInt(version);
+    (0, utils_1.assert)(numberedVersion >= 5, `Contract Storage Api Only Available for metadata version >= 5, current version: ${version}`);
+};
+exports.ensureStorageApiSupports = ensureStorageApiSupports;
+function ensurePalletPresence(client, registry) {
+    if (registry.isRevive()) {
+        try {
+            !!client.call.reviveApi.call.meta && !!client.tx.revive.call.meta;
+        }
+        catch {
+            throw new utils_1.DedotError('Pallet Revive is not available');
+        }
+    }
+    else {
+        try {
+            !!client.call.contractsApi.call.meta && !!client.tx.contracts.call.meta;
+        }
+        catch {
+            throw new utils_1.DedotError('Pallet Contracts is not available');
+        }
+    }
+}
+exports.ensurePalletPresence = ensurePalletPresence;
+async function ensureContractPresence(client, registry, address) {
+    const contractInfo = await (() => {
+        if (registry.isRevive()) {
+            return client.query.revive.contractInfoOf(address);
+        }
+        else {
+            return client.query.contracts.contractInfoOf(address);
+        }
+    })();
+    (0, utils_1.ensurePresence)(contractInfo, `Contract with address ${address} does not exist on chain!`);
+}
+exports.ensureContractPresence = ensureContractPresence;
+function ensureValidContractAddress(address, registry) {
+    if (registry.isRevive()) {
+        (0, utils_1.assert)((0, utils_1.isEvmAddress)(address), `Invalid contract address: ${address}. Expected an EVM 20-byte address as a hex string or a Uint8Array`);
+    }
+    else {
+        (0, utils_1.assert)((0, utils_1.hexToU8a)((0, codecs_1.accountId32ToHex)(address)).length === 32, `Invalid contract address: ${address}. Expected a Substrate 32-byte address as a hex string or a Uint8Array`);
+    }
+}
+exports.ensureValidContractAddress = ensureValidContractAddress;
+function ensureValidCodeHashOrCode(codeHashOrCode, registry) {
+    (0, utils_1.assert)((0, utils_1.toU8a)(codeHashOrCode).length === 32 || (registry.isRevive() ? (0, utils_1.isPvm)(codeHashOrCode) : (0, utils_1.isWasm)(codeHashOrCode)), 'Invalid code hash or code: expected a hash of 32-byte or a valid PVM/WASM code as a hex string or a Uint8Array');
+}
+exports.ensureValidCodeHashOrCode = ensureValidCodeHashOrCode;
+const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
+const SUPPORTED_VERSIONS = [6, 5, '4'];
+function ensureSupportedContractMetadataVersion(metadata) {
+    // This is for V1, V2, V3
+    const unsupportedVersion = UNSUPPORTED_VERSIONS.find((o) => metadata[o]);
+    if (unsupportedVersion) {
+        throw new utils_1.DedotError(`Unsupported metadata version: ${unsupportedVersion}`);
+    }
+    // This is for V4, V5, V6
+    if (!SUPPORTED_VERSIONS.includes(metadata.version)) {
+        throw new utils_1.DedotError(`Unsupported metadata version: ${metadata.version}`);
+    }
+}
+exports.ensureSupportedContractMetadataVersion = ensureSupportedContractMetadataVersion;

package/cjs/utils/index.js

@@ -0,0 +1,21 @@
+"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("./types.js"), exports);
+__exportStar(require("./proxy.js"), exports);
+__exportStar(require("./ensure.js"), exports);
+__exportStar(require("./address.js"), exports);
+__exportStar(require("./storage.js"), exports);

package/cjs/utils/proxy.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newProxyChain = void 0;
+function newProxyChain(carrier) {
+    return new Proxy(carrier, {
+        get(target, property) {
+            return target.doExecute(property.toString());
+        },
+    });
+}
+exports.newProxyChain = newProxyChain;

package/cjs/utils/storage.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findStorageRootKey = void 0;
+function findStorageRootKey(layout, targetId) {
+    if (layout.root) {
+        if (layout.root.ty === targetId) {
+            return layout.root.root_key;
+        }
+        else {
+            return findStorageRootKey(layout.root.layout, targetId);
+        }
+    }
+    else if (layout.array) {
+        return findStorageRootKey(layout.array.layout, targetId);
+    }
+    else if (layout.enum) {
+        for (const one of Object.values(layout.enum.variants)) {
+            for (const structField of one.fields) {
+                const potentialKey = findStorageRootKey(structField.layout, targetId);
+                if (potentialKey)
+                    return potentialKey;
+            }
+        }
+        return undefined;
+    }
+    else if (layout.leaf) {
+        if (layout.leaf.ty === targetId) {
+            return layout.leaf.key;
+        }
+        else {
+            return undefined;
+        }
+    }
+    else if (layout.struct) {
+        for (const structField of layout.struct.fields) {
+            const potentialKey = findStorageRootKey(structField.layout, targetId);
+            if (potentialKey)
+                return potentialKey;
+        }
+        return undefined;
+    }
+    throw new Error(`Layout Not Supported: ${JSON.stringify(layout)}`);
+}
+exports.findStorageRootKey = findStorageRootKey;

package/cjs/{utils.js → utils/types.js}

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toReturnFlags = exports.normalizeLabel = exports.ensureSupportContractsPallet = exports.newProxyChain = exports.parseRawMetadata = exports.normalizeContractTypeDef = exports.extractContractTypes = void 0;
+exports.isLazyType = exports.KnownLazyType = exports.toReturnFlags = exports.normalizeLabel = exports.normalizeContractTypeDef = exports.extractContractTypes = void 0;
 const utils_1 = require("@dedot/utils");
 const extractContractTypes = (contractMetadata) => {
     const { types } = contractMetadata;
@@ -80,39 +80,6 @@ const normalizeContractTypeDef = (def) => {
     return { type, value };
 };
 exports.normalizeContractTypeDef = normalizeContractTypeDef;
-const UNSUPPORTED_VERSIONS = ['V3', 'V2', 'V1'];
-const SUPPORTED_VERSIONS = [5, '4'];
-const parseRawMetadata = (rawMetadata) => {
-    const metadata = JSON.parse(rawMetadata);
-    // This is for V1, V2, V3
-    const unsupportedVersion = UNSUPPORTED_VERSIONS.find((o) => metadata[o]);
-    if (unsupportedVersion) {
-        throw new Error(`Unsupported metadata version: ${unsupportedVersion}`);
-    }
-    // This is for V4, V5
-    if (!SUPPORTED_VERSIONS.includes(metadata.version)) {
-        throw new Error(`Unsupported metadata version: ${metadata.version}`);
-    }
-    return metadata;
-};
-exports.parseRawMetadata = parseRawMetadata;
-function newProxyChain(carrier) {
-    return new Proxy(carrier, {
-        get(target, property) {
-            return target.doExecute(property.toString());
-        },
-    });
-}
-exports.newProxyChain = newProxyChain;
-function ensureSupportContractsPallet(client) {
-    try {
-        !!client.call.contractsApi.call.meta && !!client.tx.contracts.call.meta;
-    }
-    catch {
-        throw new Error('Contracts pallet is not available');
-    }
-}
-exports.ensureSupportContractsPallet = ensureSupportContractsPallet;
 function normalizeLabel(label) {
     if (!label)
         return '';
@@ -128,3 +95,33 @@ function toReturnFlags(bits) {
     };
 }
 exports.toReturnFlags = toReturnFlags;
+const KNOWN_LAZY_TYPES = {
+    LAZY: ['ink_storage', 'lazy', 'Lazy'].join('::'),
+    MAPPING: ['ink_storage', 'lazy', 'mapping', 'Mapping'].join('::'),
+    STORAGE_VEC: ['ink_storage', 'lazy', 'vec', 'StorageVec'].join('::'),
+};
+var KnownLazyType;
+(function (KnownLazyType) {
+    KnownLazyType["LAZY"] = "LAZY";
+    KnownLazyType["MAPPING"] = "MAPPING";
+    KnownLazyType["STORAGE_VEC"] = "STORAGE_VEC";
+})(KnownLazyType || (exports.KnownLazyType = KnownLazyType = {}));
+/**
+ * Check if a type is lazy/non-packed storage
+ *
+ * @param typePath
+ */
+function isLazyType(typePath) {
+    if (!typePath)
+        return;
+    if (Array.isArray(typePath)) {
+        typePath = typePath.join('::');
+    }
+    if (typePath === KNOWN_LAZY_TYPES.LAZY)
+        return KnownLazyType.LAZY;
+    if (typePath === KNOWN_LAZY_TYPES.MAPPING)
+        return KnownLazyType.MAPPING;
+    if (typePath === KNOWN_LAZY_TYPES.STORAGE_VEC)
+        return KnownLazyType.STORAGE_VEC;
+}
+exports.isLazyType = isLazyType;

package/errors.js

@@ -1,5 +1,5 @@
-import { DedotError, assert } from '@dedot/utils';
-import { toReturnFlags } from './utils.js';
+import { assert, DedotError } from '@dedot/utils';
+import { toReturnFlags } from './utils/index.js';
 /**
  * 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`.

package/executor/ConstructorQueryExecutor.js

@@ -1,6 +1,6 @@
-import { assert, assertFalse, concatU8a, hexToU8a, isNull, isUndefined, isWasm, u8aToHex } from '@dedot/utils';
+import { assert, assertFalse, concatU8a, hexToU8a, isPvm, isUndefined, isWasm, toHex, toU8a, u8aToHex, } from '@dedot/utils';
 import { ContractInstantiateDispatchError, ContractInstantiateLangError } from '../errors.js';
-import { toReturnFlags } from '../utils.js';
+import { toReturnFlags } from '../utils/index.js';
 import { DeployerExecutor } from './abstract/index.js';
 export class ConstructorQueryExecutor extends DeployerExecutor {
     doExecute(constructor) {
@@ -11,16 +11,55 @@ export class ConstructorQueryExecutor extends DeployerExecutor {
             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}`);
             const callOptions = (params[args.length] || {});
-            const { caller = this.options.defaultCaller, value = 0n, gasLimit, storageDepositLimit, salt = '0x', } = callOptions;
+            const { caller = this.options.defaultCaller, // --
+            value = 0n, gasLimit, storageDepositLimit, salt, } = callOptions;
             assert(caller, 'Expected a valid caller address in ConstructorCallOptions');
-            assertFalse(isNull(salt) || isUndefined(salt), 'Expected a salt in ConstructorCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
+            const isUpload = isPvm(this.code) || isWasm(this.code);
             const code = {
-                type: isWasm(this.code) ? 'Upload' : 'Existing',
+                type: isUpload ? 'Upload' : 'Existing',
                 value: this.code,
             };
-            const raw = await this.client.call.contractsApi.instantiate(caller, value, gasLimit, storageDepositLimit, code, bytes, salt);
+            const client = this.client;
+            const raw = await (async () => {
+                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');
+                    const raw = await client.call.reviveApi.instantiate(caller, // --
+                    value, gasLimit, storageDepositLimit, code, bytes, salt ? 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,
+                    };
+                }
+                else {
+                    const raw = await client.call.contractsApi.instantiate(caller, // --
+                    value, gasLimit, storageDepositLimit, code, bytes, salt || '0x');
+                    const result = raw.result;
+                    if (result.isOk) {
+                        // @ts-ignore
+                        result.value.address = result.value.accountId.address();
+                        // @ts-ignore
+                        delete result.value.accountId;
+                    }
+                    return {
+                        gasConsumed: raw.gasConsumed,
+                        gasRequired: raw.gasRequired,
+                        storageDeposit: raw.storageDeposit,
+                        debugMessage: raw.debugMessage,
+                        result,
+                    };
+                }
+            })();
             if (raw.result.isErr) {
                 throw new ContractInstantiateDispatchError(raw.result.err, raw);
             }
@@ -32,8 +71,9 @@ export class ConstructorQueryExecutor extends DeployerExecutor {
             return {
                 data: data.value,
                 raw,
-                address: raw.result.value.accountId,
+                address: raw.result.value.address,
                 flags: toReturnFlags(bits),
+                inputData: bytes,
             };
         };
         callFn.meta = meta;

package/executor/ConstructorTxExecutor.js

@@ -1,4 +1,4 @@
-import { assert, assertFalse, concatU8a, hexToU8a, isNull, isUndefined, isWasm, u8aToHex } from '@dedot/utils';
+import { assert, concatU8a, hexToU8a, isPvm, isUndefined, isWasm, toHex, toU8a, u8aToHex } from '@dedot/utils';
 import { DeployerExecutor } from './abstract/index.js';
 export class ConstructorTxExecutor extends DeployerExecutor {
     doExecute(constructor) {
@@ -8,17 +8,28 @@ export class ConstructorTxExecutor extends DeployerExecutor {
             const { args } = meta;
             assert(params.length === args.length + 1, `Expected ${args.length + 1} arguments, got ${params.length}`);
             const txCallOptions = params[args.length];
-            const { value = 0n, gasLimit, storageDepositLimit, salt = '0x' } = txCallOptions;
+            const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
             assert(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
-            assertFalse(isNull(salt) || isUndefined(salt), 'Expected a salt in ConstructorCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
-            if (isWasm(this.code)) {
-                return this.client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt);
+            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);
+                }
+                else {
+                    return client.tx.revive.instantiate(value, gasLimit, storageDepositLimit, toHex(this.code), bytes, salt ? toHex(salt) : undefined);
+                }
             }
             else {
-                return this.client.tx.contracts.instantiate(value, // prettier-end-here
-                gasLimit, storageDepositLimit, this.code, bytes, salt);
+                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');
+                }
             }
         };
         callFn.meta = meta;

package/executor/QueryExecutor.js

@@ -1,6 +1,6 @@
 import { assert, assertFalse, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
 import { ContractDispatchError, ContractLangError } from '../errors.js';
-import { toReturnFlags } from '../utils.js';
+import { ensureContractPresence, toReturnFlags } from '../utils/index.js';
 import { ContractExecutor } from './abstract/index.js';
 export class QueryExecutor extends ContractExecutor {
     doExecute(message) {
@@ -15,7 +15,31 @@ export class QueryExecutor extends ContractExecutor {
             assert(caller, 'Expected a valid caller address in ContractCallOptions');
             const formattedInputs = args.map((arg, index) => this.tryEncode(arg, params[index]));
             const bytes = u8aToHex(concatU8a(hexToU8a(meta.selector), ...formattedInputs));
-            const raw = await this.client.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            const client = this.client;
+            await ensureContractPresence(client, this.registry, this.address);
+            const raw = await (async () => {
+                if (this.registry.isRevive()) {
+                    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,
+                    };
+                }
+                else {
+                    const raw = await client.call.contractsApi.call(caller, // --
+                    this.address, value, gasLimit, storageDepositLimit, bytes);
+                    return {
+                        gasConsumed: raw.gasConsumed,
+                        gasRequired: raw.gasRequired,
+                        storageDeposit: raw.storageDeposit,
+                        debugMessage: raw.debugMessage,
+                        result: raw.result,
+                    };
+                }
+            })();
             if (raw.result.isErr) {
                 throw new ContractDispatchError(raw.result.err, raw);
             }
@@ -28,6 +52,7 @@ export class QueryExecutor extends ContractExecutor {
                 data: data.value,
                 raw,
                 flags: toReturnFlags(bits),
+                inputData: bytes,
             };
         };
         callFn.meta = meta;

package/executor/TxExecutor.js

@@ -1,4 +1,4 @@
-import { assert, concatU8a, hexToU8a, u8aToHex } from '@dedot/utils';
+import { assert, concatU8a, hexToU8a, isUndefined, u8aToHex } from '@dedot/utils';
 import { ContractExecutor } from './abstract/index.js';
 export class TxExecutor extends ContractExecutor {
     doExecute(message) {
@@ -12,7 +12,16 @@ export class TxExecutor extends ContractExecutor {
             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));
-            return this.client.tx.contracts.call(this.address, value, gasLimit, storageDepositLimit, bytes);
+            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);
+            }
         };
         callFn.meta = meta;
         return callFn;

package/executor/abstract/ContractExecutor.d.ts

@@ -1,12 +1,11 @@
 import { ISubstrateClient } from '@dedot/api';
-import { AccountId32, AccountId32Like } from '@dedot/codecs';
 import { GenericSubstrateApi } from '@dedot/types';
 import { TypinkRegistry } from '../../TypinkRegistry.js';
-import { ContractCallMessage, ExecutionOptions } from '../../types/index.js';
+import { ContractAddress, ContractCallMessage, ExecutionOptions } from '../../types/index.js';
 import { Executor } from './Executor.js';
 export declare abstract class ContractExecutor<ChainApi extends GenericSubstrateApi> extends Executor<ChainApi> {
-    readonly address: AccountId32;
-    constructor(client: ISubstrateClient<ChainApi>, registry: TypinkRegistry, address: AccountId32Like, options?: ExecutionOptions);
+    readonly address: ContractAddress;
+    constructor(client: ISubstrateClient<ChainApi>, registry: TypinkRegistry, address: ContractAddress, options?: ExecutionOptions);
     protected findMessage(message: string): ContractCallMessage | undefined;
     protected findTxMessage(message: string): ContractCallMessage | undefined;
 }

package/executor/abstract/ContractExecutor.js

@@ -1,11 +1,10 @@
-import { AccountId32 } from '@dedot/codecs';
-import { normalizeLabel } from '../../utils.js';
+import { normalizeLabel } from '../../utils/index.js';
 import { Executor } from './Executor.js';
 export class ContractExecutor extends Executor {
     address;
     constructor(client, registry, address, options) {
         super(client, registry, options);
-        this.address = new AccountId32(address);
+        this.address = address;
     }
     findMessage(message) {
         return this.metadata.spec.messages.find((one) => normalizeLabel(one.label) === message);

package/executor/abstract/DeployerExecutor.js

@@ -1,4 +1,4 @@
-import { normalizeLabel } from '../../utils.js';
+import { normalizeLabel } from '../../utils/index.js';
 import { Executor } from './Executor.js';
 export class DeployerExecutor extends Executor {
     code;

package/index.d.ts

@@ -1,4 +1,4 @@
-export * from './utils.js';
+export * from './utils/index.js';
 export * from './errors.js';
 export * from './executor/index.js';
 export * from './types/index.js';

package/index.js

@@ -1,4 +1,4 @@
-export * from './utils.js';
+export * from './utils/index.js';
 export * from './errors.js';
 export * from './executor/index.js';
 export * from './types/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/contracts",
-  "version": "0.12.1-next.c7fd0a6c.2+c7fd0a6c",
+  "version": "0.13.0",
   "description": "Delightful ink! Contract APIs",
   "author": "Tung Vu <tung@dedot.dev>",
   "homepage": "https://dedot.dev",
@@ -18,10 +18,11 @@
     "test": "npx vitest --watch=false"
   },
   "dependencies": {
-    "@dedot/api": "0.12.1-next.c7fd0a6c.2+c7fd0a6c",
-    "@dedot/codecs": "0.12.1-next.c7fd0a6c.2+c7fd0a6c",
-    "@dedot/types": "0.12.1-next.c7fd0a6c.2+c7fd0a6c",
-    "@dedot/utils": "0.12.1-next.c7fd0a6c.2+c7fd0a6c"
+    "@dedot/api": "0.13.0",
+    "@dedot/codecs": "0.13.0",
+    "@dedot/types": "0.13.0",
+    "@dedot/utils": "0.13.0",
+    "@ethereumjs/rlp": "^10.0.0"
   },
   "publishConfig": {
     "access": "public",
@@ -31,7 +32,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "c7fd0a6c35b80d78cbf6dead68b12b2820f16f0b",
+  "gitHead": "b9193d170fc63ebd64b75f37f8276a7159e2af55",
   "module": "./index.js",
   "types": "./index.d.ts",
   "exports": {

package/storage/BaseLazyObject.d.ts

@@ -0,0 +1,10 @@
+import { HexString } from '@dedot/utils';
+import { TypinkRegistry } from 'src/TypinkRegistry';
+import { ContractType } from 'src/types';
+export declare abstract class BaseLazyObject {
+    readonly typeDef: ContractType;
+    readonly registry: TypinkRegistry;
+    constructor(typeDef: ContractType, registry: TypinkRegistry);
+    findStorageRootLayout(typeId: number): HexString;
+    getContractStorage(key: Uint8Array | HexString): Promise<HexString | undefined>;
+}

package/storage/BaseLazyObject.js

@@ -0,0 +1,21 @@
+import { assert, toU8a } from '@dedot/utils';
+import { findStorageRootKey } from '../utils/index.js';
+export class BaseLazyObject {
+    typeDef;
+    registry;
+    constructor(typeDef, registry) {
+        this.typeDef = typeDef;
+        this.registry = registry;
+    }
+    findStorageRootLayout(typeId) {
+        const rootLayout = this.registry.metadata.storage;
+        const rootKey = findStorageRootKey(rootLayout, typeId);
+        assert(rootKey, 'Root Key Not Found');
+        return rootKey;
+    }
+    getContractStorage(key) {
+        const { getStorage } = this.registry.options || {};
+        assert(getStorage, 'getStorage is not available');
+        return getStorage(toU8a(key));
+    }
+}

package/storage/LazyMapping.d.ts

@@ -0,0 +1,4 @@
+import { BaseLazyObject } from './BaseLazyObject.js';
+export declare class LazyMapping extends BaseLazyObject {
+    get(key: any): Promise<unknown>;
+}