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

package/cjs/TypinkRegistry.js

@@ -27,15 +27,99 @@ exports.TypinkRegistry = void 0;
 const codecs_1 = require("@dedot/codecs");
 const $ = __importStar(require("@dedot/shape"));
 const utils_1 = require("@dedot/utils");
-const utils_js_1 = require("./utils.js");
+const index_js_1 = require("./storage/index.js");
+const index_js_2 = require("./utils/index.js");
 class TypinkRegistry extends codecs_1.TypeRegistry {
-    #metadata;
-    constructor(metadata) {
-        super((0, utils_js_1.extractContractTypes)(metadata));
-        this.#metadata = metadata;
+    metadata;
+    options;
+    constructor(metadata, options) {
+        (0, index_js_2.ensureSupportedContractMetadataVersion)(metadata);
+        super((0, index_js_2.extractContractTypes)(metadata));
+        this.metadata = metadata;
+        this.options = options;
     }
-    get metadata() {
-        return this.#metadata;
+    findCodec(typeId) {
+        const types = this.metadata.types;
+        const typeDef = types.find(({ id }) => id == typeId);
+        const $codec = super.findCodec(typeId);
+        const lazyType = (0, index_js_2.isLazyType)(typeDef.type.path);
+        if (lazyType === index_js_2.KnownLazyType.MAPPING) {
+            return this.#createLazyCodec(index_js_1.LazyMapping, $codec, typeDef);
+        }
+        else if (lazyType === index_js_2.KnownLazyType.LAZY) {
+            return this.#createLazyCodec(index_js_1.LazyObject, $codec, typeDef);
+        }
+        else if (lazyType === index_js_2.KnownLazyType.STORAGE_VEC) {
+            return this.#createLazyCodec(index_js_1.LazyStorageVec, $codec, typeDef);
+        }
+        return $codec;
+    }
+    /**
+     * Creates a lazy codec for a given type ID, extracting only storage types that is lazy/non-packed storage.
+     *
+     * @param typeId The type ID to create a lazy codec for
+     * @returns A shape codec containing only lazy/non-packed storage fields, or null if no lazy fields exist
+     */
+    createLazyCodec(typeId) {
+        const typeDef = this.findType(typeId);
+        // Check if this is a lazy storage type we want to keep
+        const lazyType = (0, index_js_2.isLazyType)(typeDef.path);
+        if (lazyType)
+            return this.findCodec(typeId);
+        // For non-lazy types, we need to recursively process the structure
+        const { typeDef: def } = typeDef;
+        // We only support Struct type for now.
+        if (def.type === 'Struct') {
+            const { fields } = def.value;
+            if (fields.length === 0) {
+                return null;
+            }
+            // Handle tuple-like structs (fields with undefined names)
+            if (fields[0].name === undefined) {
+                if (fields.length === 1) {
+                    // Single unnamed field - check if it contains lazy types
+                    return this.createLazyCodec(fields[0].typeId);
+                }
+                else {
+                    return null; // Unsupported Lazy Codec Structure
+                }
+            }
+            else {
+                // Named struct fields - create struct with only lazy fields
+                const lazyFields = {};
+                let hasLazyFields = false;
+                for (const field of fields) {
+                    // Skip fields with undefined names in named structs
+                    if (field.name === undefined)
+                        continue;
+                    // Recursively check if this field contains lazy types
+                    const fieldCodec = this.createLazyCodec(field.typeId);
+                    // Only include fields that have lazy types
+                    if (fieldCodec) {
+                        lazyFields[field.name] = fieldCodec;
+                        hasLazyFields = true;
+                    }
+                }
+                // If no lazy fields, return null
+                if (!hasLazyFields) {
+                    return null;
+                }
+                return $.Struct(lazyFields);
+            }
+        }
+        return null;
+    }
+    #enhanceLazyCodec($codec, typeDef) {
+        const $Codec = $.Tuple($codec);
+        // @ts-ignore
+        $Codec.subDecode = () => {
+            return [typeDef, this];
+        };
+        return $Codec;
+    }
+    #createLazyCodec(LazyClazz, $codec, typeDef) {
+        // @ts-ignore
+        return $.instance(LazyClazz, this.#enhanceLazyCodec($codec, typeDef), () => ({}));
     }
     decodeEvents(records, contract) {
         return records
@@ -44,27 +128,35 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
     }
     decodeEvent(eventRecord, contract) {
         (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event, contract), 'Invalid ContractEmitted Event');
-        const { version } = this.#metadata;
+        const { version } = this.metadata;
         switch (version) {
+            case 6:
             case 5:
-                return this.#decodeEventV5(eventRecord);
+                return this.isRevive() // --
+                    ? this.#decodeEventV6(eventRecord)
+                    : this.#decodeEventV5(eventRecord);
             case '4':
                 return this.#decodeEventV4(eventRecord);
             default:
                 throw new utils_1.DedotError('Unsupported metadata version!');
         }
     }
-    #isContractEmittedEvent(event, contract) {
-        const eventMatched = event.pallet === 'Contracts' &&
+    #isContractEmittedEvent(event, contractAddress) {
+        const eventMatched = (this.isRevive() // --
+            ? event.pallet === 'Revive'
+            : event.pallet === 'Contracts') &&
             typeof event.palletEvent === 'object' &&
             event.palletEvent.name === 'ContractEmitted';
         if (!eventMatched)
             return false;
-        if (contract) {
+        if (contractAddress) {
             // @ts-ignore
             const emittedContract = event.palletEvent.data?.contract;
-            if (emittedContract instanceof codecs_1.AccountId32) {
-                return emittedContract.eq(contract);
+            if (this.isRevive()) {
+                return emittedContract === contractAddress;
+            }
+            else if (emittedContract instanceof codecs_1.AccountId32) {
+                return emittedContract.eq(contractAddress);
             }
             else {
                 return false;
@@ -73,32 +165,51 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
         return true;
     }
     #decodeEventV4(eventRecord) {
-        (0, utils_1.assert)(this.#metadata.version === '4', 'Invalid metadata version!');
+        (0, utils_1.assert)(this.metadata.version === '4', 'Invalid metadata version!');
         (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
         const data = (0, utils_1.hexToU8a)(eventRecord.event.palletEvent.data.data);
         const index = data.at(0);
         (0, utils_1.assert)(index !== undefined, 'Unable to decode event index!');
-        const event = this.#metadata.spec.events[index];
+        const event = this.metadata.spec.events[index];
         (0, utils_1.assert)(event, `Event index not found: ${index.toString()}`);
         return this.#tryDecodeEvent(event, data.subarray(1));
     }
-    #decodeEventV5(eventRecord) {
-        (0, utils_1.assert)(this.#metadata.version === 5, 'Invalid metadata version!');
-        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
-        const data = (0, utils_1.hexToU8a)(eventRecord.event.palletEvent.data.data);
-        const signatureTopic = eventRecord.topics.at(0);
+    #detectEventMeta(signatureTopics) {
+        // Only version >= 5 metadata supports signature topics
+        (0, utils_1.assert)(+this.metadata.version >= 5, 'Invalid metadata version!');
         let eventMeta;
-        if (signatureTopic) {
-            eventMeta = this.#metadata.spec.events.find((one) => one.signature_topic === signatureTopic);
+        const targetSignatureTopic = signatureTopics.at(0);
+        if (targetSignatureTopic) {
+            // @ts-ignore
+            eventMeta = this.metadata.spec.events.find((one) => one.signature_topic === targetSignatureTopic);
         }
         // TODO: Handle multiple anonymous events
         // If `event` does not exist, it means it's an anonymous event
         // that does not contain a signature topic in the metadata.
         if (!eventMeta) {
-            const potentialEvents = this.#metadata.spec.events.filter((one) => !one.signature_topic && one.args.filter((arg) => arg.indexed).length === eventRecord.topics.length);
+            const potentialEvents = this.metadata.spec.events.filter(
+            // @ts-ignore
+            (one) => !one.signature_topic && one.args.filter((arg) => arg.indexed).length === signatureTopics.length);
             (0, utils_1.assert)(potentialEvents.length === 1, 'Unable to determine event!');
             eventMeta = potentialEvents[0];
         }
+        return eventMeta;
+    }
+    #decodeEventV5(eventRecord) {
+        (0, utils_1.assert)(this.metadata.version === 5, 'Invalid metadata version!');
+        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
+        const data = (0, utils_1.hexToU8a)(eventRecord.event.palletEvent.data.data);
+        const signatureTopics = eventRecord.topics;
+        const eventMeta = this.#detectEventMeta(signatureTopics);
+        return this.#tryDecodeEvent(eventMeta, data);
+    }
+    #decodeEventV6(eventRecord) {
+        (0, utils_1.assert)(this.isRevive(), 'Invalid metadata version!');
+        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
+        const eventData = eventRecord.event.palletEvent.data;
+        const data = (0, utils_1.hexToU8a)(eventData.data);
+        const signatureTopics = eventData.topics;
+        const eventMeta = this.#detectEventMeta(signatureTopics);
         return this.#tryDecodeEvent(eventMeta, data);
     }
     #tryDecodeEvent(eventMeta, raw) {
@@ -114,5 +225,14 @@ class TypinkRegistry extends codecs_1.TypeRegistry {
         const name = (0, utils_1.stringPascalCase)(label);
         return args.length ? { name, data } : { name };
     }
+    /**
+     * Check if the contract is Revive Compatible (ink!v6)
+     */
+    isRevive() {
+        return (+this.metadata.version >= 6 ||
+            this.metadata.source.language // TODO remove this
+                .toLowerCase() // --
+                .startsWith('ink! 6.'));
+    }
 }
 exports.TypinkRegistry = TypinkRegistry;

package/cjs/errors.js

@@ -2,7 +2,7 @@
 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 utils_js_1 = require("./utils.js");
+const index_js_1 = require("./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`.
@@ -85,7 +85,7 @@ class ContractInstantiateLangError extends ContractInstantiateError {
         (0, utils_1.assert)(raw.result.isOk, 'Should not throw DispatchError!');
         super(raw);
         this.langError = err;
-        this.flags = (0, utils_js_1.toReturnFlags)(raw.result.value.result.flags.bits);
+        this.flags = (0, index_js_1.toReturnFlags)(raw.result.value.result.flags.bits);
         this.message = `Lange error: ${JSON.stringify(err)}`;
     }
 }
@@ -172,7 +172,7 @@ class ContractLangError extends ContractExecutionError {
         (0, utils_1.assert)(raw.result.isOk, 'Should not throw DispatchError!');
         super(raw);
         this.langError = err;
-        this.flags = (0, utils_js_1.toReturnFlags)(raw.result.value.flags.bits);
+        this.flags = (0, index_js_1.toReturnFlags)(raw.result.value.flags.bits);
         this.message = `Lange error: ${JSON.stringify(err)}`;
     }
 }

package/cjs/executor/ConstructorQueryExecutor.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConstructorQueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
 const errors_js_1 = require("../errors.js");
-const utils_js_1 = require("../utils.js");
-const index_js_1 = require("./abstract/index.js");
-class ConstructorQueryExecutor extends index_js_1.DeployerExecutor {
+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) {
         const meta = this.findConstructorMeta(constructor);
         (0, utils_1.assert)(meta, `Constructor message not found: ${constructor}`);
@@ -14,16 +14,55 @@ class ConstructorQueryExecutor extends index_js_1.DeployerExecutor {
             (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}`);
             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;
             (0, utils_1.assert)(caller, 'Expected a valid caller address in ConstructorCallOptions');
-            (0, utils_1.assertFalse)((0, utils_1.isNull)(salt) || (0, utils_1.isUndefined)(salt), 'Expected a salt in ConstructorCallOptions');
             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);
             const code = {
-                type: (0, utils_1.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()) {
+                    (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 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,
+                    };
+                }
+                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 errors_js_1.ContractInstantiateDispatchError(raw.result.err, raw);
             }
@@ -35,8 +74,9 @@ class ConstructorQueryExecutor extends index_js_1.DeployerExecutor {
             return {
                 data: data.value,
                 raw,
-                address: raw.result.value.accountId,
-                flags: (0, utils_js_1.toReturnFlags)(bits),
+                address: raw.result.value.address,
+                flags: (0, index_js_1.toReturnFlags)(bits),
+                inputData: bytes,
             };
         };
         callFn.meta = meta;

package/cjs/executor/ConstructorTxExecutor.js

@@ -11,17 +11,28 @@ class ConstructorTxExecutor extends index_js_1.DeployerExecutor {
             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];
-            const { value = 0n, gasLimit, storageDepositLimit, salt = '0x' } = txCallOptions;
+            const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
             (0, utils_1.assert)(gasLimit, 'Expected a gas limit in ConstructorTxOptions');
-            (0, utils_1.assertFalse)((0, utils_1.isNull)(salt) || (0, utils_1.isUndefined)(salt), 'Expected a salt in ConstructorCallOptions');
             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));
-            if ((0, utils_1.isWasm)(this.code)) {
-                return this.client.tx.contracts.instantiateWithCode(value, gasLimit, storageDepositLimit, this.code, bytes, salt);
+            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);
+                }
+                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 this.client.tx.contracts.instantiate(value, // prettier-end-here
-                gasLimit, storageDepositLimit, this.code, bytes, salt);
+                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');
+                }
             }
         };
         callFn.meta = meta;

package/cjs/executor/QueryExecutor.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryExecutor = void 0;
 const utils_1 = require("@dedot/utils");
 const errors_js_1 = require("../errors.js");
-const utils_js_1 = require("../utils.js");
-const index_js_1 = require("./abstract/index.js");
-class QueryExecutor extends index_js_1.ContractExecutor {
+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) {
         const meta = this.findMessage(message);
         (0, utils_1.assert)(meta, `Query message not found: ${message}`);
@@ -18,7 +18,31 @@ class QueryExecutor extends index_js_1.ContractExecutor {
             (0, utils_1.assert)(caller, 'Expected a valid caller address in ContractCallOptions');
             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 raw = await this.client.call.contractsApi.call(caller, this.address, value, gasLimit, storageDepositLimit, bytes);
+            const client = this.client;
+            await (0, index_js_1.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 errors_js_1.ContractDispatchError(raw.result.err, raw);
             }
@@ -30,7 +54,8 @@ class QueryExecutor extends index_js_1.ContractExecutor {
             return {
                 data: data.value,
                 raw,
-                flags: (0, utils_js_1.toReturnFlags)(bits),
+                flags: (0, index_js_1.toReturnFlags)(bits),
+                inputData: bytes,
             };
         };
         callFn.meta = meta;

package/cjs/executor/TxExecutor.js

@@ -15,7 +15,16 @@ class TxExecutor extends index_js_1.ContractExecutor {
             (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));
-            return this.client.tx.contracts.call(this.address, value, gasLimit, storageDepositLimit, bytes);
+            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);
+            }
         };
         callFn.meta = meta;
         return callFn;

package/cjs/executor/abstract/ContractExecutor.js

@@ -1,20 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractExecutor = void 0;
-const codecs_1 = require("@dedot/codecs");
-const utils_js_1 = require("../../utils.js");
+const index_js_1 = require("../../utils/index.js");
 const Executor_js_1 = require("./Executor.js");
 class ContractExecutor extends Executor_js_1.Executor {
     address;
     constructor(client, registry, address, options) {
         super(client, registry, options);
-        this.address = new codecs_1.AccountId32(address);
+        this.address = address;
     }
     findMessage(message) {
-        return this.metadata.spec.messages.find((one) => (0, utils_js_1.normalizeLabel)(one.label) === message);
+        return this.metadata.spec.messages.find((one) => (0, index_js_1.normalizeLabel)(one.label) === message);
     }
     findTxMessage(message) {
-        return this.metadata.spec.messages.find((one) => one.mutates && (0, utils_js_1.normalizeLabel)(one.label) === message);
+        return this.metadata.spec.messages.find((one) => one.mutates && (0, index_js_1.normalizeLabel)(one.label) === message);
     }
 }
 exports.ContractExecutor = ContractExecutor;

package/cjs/executor/abstract/DeployerExecutor.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DeployerExecutor = void 0;
-const utils_js_1 = require("../../utils.js");
+const index_js_1 = require("../../utils/index.js");
 const Executor_js_1 = require("./Executor.js");
 class DeployerExecutor extends Executor_js_1.Executor {
     code;
@@ -10,7 +10,7 @@ class DeployerExecutor extends Executor_js_1.Executor {
         this.code = code;
     }
     findConstructorMeta(constructor) {
-        return this.metadata.spec.constructors.find((one) => (0, utils_js_1.normalizeLabel)(one.label) === constructor);
+        return this.metadata.spec.constructors.find((one) => (0, index_js_1.normalizeLabel)(one.label) === constructor);
     }
 }
 exports.DeployerExecutor = DeployerExecutor;

package/cjs/index.js

@@ -14,7 +14,7 @@ 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("./utils.js"), exports);
+__exportStar(require("./utils/index.js"), exports);
 __exportStar(require("./errors.js"), exports);
 __exportStar(require("./executor/index.js"), exports);
 __exportStar(require("./types/index.js"), exports);

package/cjs/storage/BaseLazyObject.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseLazyObject = void 0;
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../utils/index.js");
+class BaseLazyObject {
+    typeDef;
+    registry;
+    constructor(typeDef, registry) {
+        this.typeDef = typeDef;
+        this.registry = registry;
+    }
+    findStorageRootLayout(typeId) {
+        const rootLayout = this.registry.metadata.storage;
+        const rootKey = (0, index_js_1.findStorageRootKey)(rootLayout, typeId);
+        (0, utils_1.assert)(rootKey, 'Root Key Not Found');
+        return rootKey;
+    }
+    getContractStorage(key) {
+        const { getStorage } = this.registry.options || {};
+        (0, utils_1.assert)(getStorage, 'getStorage is not available');
+        return getStorage((0, utils_1.toU8a)(key));
+    }
+}
+exports.BaseLazyObject = BaseLazyObject;

package/cjs/storage/LazyMapping.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyMapping = void 0;
+const utils_1 = require("@dedot/utils");
+const BaseLazyObject_js_1 = require("./BaseLazyObject.js");
+class LazyMapping extends BaseLazyObject_js_1.BaseLazyObject {
+    async get(key) {
+        const { id, type: { params }, } = this.typeDef;
+        const [keyType, valueType] = params;
+        const $Key = this.registry.findCodec(keyType.type);
+        const $Value = this.registry.findCodec(valueType.type);
+        const rootKey = this.findStorageRootLayout(id);
+        const encodedKey = $Key.tryEncode(key);
+        const storageKey = (0, utils_1.concatU8a)((0, utils_1.toU8a)(rootKey), encodedKey);
+        const rawValue = await this.getContractStorage(storageKey);
+        if (rawValue) {
+            return $Value.tryDecode(rawValue);
+        }
+        return undefined;
+    }
+}
+exports.LazyMapping = LazyMapping;

package/cjs/storage/LazyObject.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyObject = void 0;
+const BaseLazyObject_js_1 = require("./BaseLazyObject.js");
+class LazyObject extends BaseLazyObject_js_1.BaseLazyObject {
+    async get() {
+        const { id, type: { params }, } = this.typeDef;
+        const [valueType] = params;
+        const $Value = this.registry.findCodec(valueType.type);
+        const rootKey = this.findStorageRootLayout(id);
+        const rawValue = await this.getContractStorage(rootKey);
+        if (rawValue) {
+            return $Value.tryDecode(rawValue);
+        }
+        return undefined;
+    }
+}
+exports.LazyObject = LazyObject;

package/cjs/storage/LazyStorageVec.js

@@ -0,0 +1,54 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LazyStorageVec = void 0;
+const $ = __importStar(require("@dedot/shape"));
+const utils_1 = require("@dedot/utils");
+const BaseLazyObject_js_1 = require("./BaseLazyObject.js");
+class LazyStorageVec extends BaseLazyObject_js_1.BaseLazyObject {
+    async len() {
+        const { id } = this.typeDef;
+        const rootKey = this.findStorageRootLayout(id);
+        const rawValue = await this.getContractStorage(rootKey);
+        if (rawValue) {
+            return $.u32.tryDecode(rawValue);
+        }
+        return 0;
+    }
+    async get(index) {
+        const { id, type: { params }, } = this.typeDef;
+        const [valueType] = params;
+        const $Value = this.registry.findCodec(valueType.type);
+        const rootKey = this.findStorageRootLayout(id);
+        const encodedKey = $.u32.tryEncode(index);
+        const storageKey = (0, utils_1.concatU8a)((0, utils_1.toU8a)(rootKey), encodedKey);
+        const rawValue = await this.getContractStorage(storageKey);
+        if (rawValue) {
+            return $Value.tryDecode(rawValue);
+        }
+        return undefined;
+    }
+}
+exports.LazyStorageVec = LazyStorageVec;

package/cjs/storage/index.js

@@ -0,0 +1,19 @@
+"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("./LazyObject.js"), exports);
+__exportStar(require("./LazyMapping.js"), exports);
+__exportStar(require("./LazyStorageVec.js"), exports);