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

package/Contract.d.ts

@@ -1,19 +1,19 @@
 import { ISubstrateClient } from '@dedot/api';
-import { AccountId32, AccountId32Like } from '@dedot/codecs';
 import { IEventRecord } from '@dedot/types';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ContractEvent, ContractMetadata, GenericContractApi, ExecutionOptions } from './types/index.js';
+import { ContractAddress, ContractEvent, ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata } from './types/index.js';
 export declare class Contract<ContractApi extends GenericContractApi = GenericContractApi> {
     #private;
     readonly client: ISubstrateClient<ContractApi['types']['ChainApi']>;
-    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: ContractMetadata | string, address: AccountId32Like, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: LooseContractMetadata | string, address: ContractAddress, options?: ExecutionOptions);
     decodeEvent(eventRecord: IEventRecord): ContractEvent;
     decodeEvents(eventRecords: IEventRecord[]): ContractEvent[];
     get metadata(): ContractMetadata;
-    get address(): AccountId32;
+    get address(): ContractAddress;
     get registry(): TypinkRegistry;
     get query(): ContractApi['query'];
     get tx(): ContractApi['tx'];
     get events(): ContractApi['events'];
     get options(): ExecutionOptions | undefined;
+    get storage(): ContractApi['storage'];
 }

package/Contract.js

@@ -1,7 +1,7 @@
-import { AccountId32 } from '@dedot/codecs';
+import { DedotError, toHex, toU8a } from '@dedot/utils';
 import { TypinkRegistry } from './TypinkRegistry.js';
 import { EventExecutor, QueryExecutor, TxExecutor } from './executor/index.js';
-import { ensureSupportContractsPallet, newProxyChain, parseRawMetadata } from './utils.js';
+import { ensurePalletPresence, ensureStorageApiSupports, ensureSupportedContractMetadataVersion, ensureValidContractAddress, newProxyChain, } from './utils/index.js';
 export class Contract {
     client;
     #registry;
@@ -10,10 +10,13 @@ export class Contract {
     #options;
     constructor(client, metadata, address, options) {
         this.client = client;
-        ensureSupportContractsPallet(client);
-        this.#address = new AccountId32(address);
-        this.#metadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
-        this.#registry = new TypinkRegistry(this.#metadata);
+        this.#metadata = (typeof metadata === 'string' ? JSON.parse(metadata) : metadata);
+        ensureSupportedContractMetadataVersion(this.metadata);
+        const getStorage = this.#getStorage.bind(this);
+        this.#registry = new TypinkRegistry(this.metadata, { getStorage });
+        ensurePalletPresence(client, this.registry);
+        ensureValidContractAddress(address, this.registry);
+        this.#address = address;
         this.#options = options;
     }
     decodeEvent(eventRecord) {
@@ -43,4 +46,36 @@ export class Contract {
     get options() {
         return this.#options;
     }
+    get storage() {
+        return {
+            root: async () => {
+                ensureStorageApiSupports(this.metadata.version);
+                const { ty, root_key } = this.metadata.storage.root;
+                const rawValue = await this.#getStorage(root_key);
+                return this.registry.findCodec(ty).tryDecode(rawValue);
+            },
+            lazy: () => {
+                ensureStorageApiSupports(this.metadata.version);
+                const { ty } = this.metadata.storage.root;
+                const $lazyCodec = this.registry.createLazyCodec(ty);
+                return $lazyCodec ? $lazyCodec.tryDecode('0x') : {};
+            },
+        };
+    }
+    #getStorage = async (key) => {
+        const result = await (async () => {
+            if (this.registry.isRevive()) {
+                return await this.client.call.reviveApi.getStorageVarKey(this.address, //--
+                toHex(key));
+            }
+            else {
+                return await this.client.call.contractsApi.getStorage(this.address, //--
+                toU8a(key));
+            }
+        })();
+        if (result.isOk) {
+            return result.value;
+        }
+        throw new DedotError(result.err);
+    };
 }

package/ContractDeployer.d.ts

@@ -1,11 +1,11 @@
 import { ISubstrateClient } from '@dedot/api';
 import { Hash } from '@dedot/codecs';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ContractMetadata, GenericContractApi, ExecutionOptions } from './types/index.js';
+import { ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata } from './types/index.js';
 export declare class ContractDeployer<ContractApi extends GenericContractApi = GenericContractApi> {
     #private;
     readonly client: ISubstrateClient<ContractApi['types']['ChainApi']>;
-    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: ContractMetadata | string, codeHashOrWasm: Hash | Uint8Array | string, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: LooseContractMetadata | string, codeHashOrCode: Hash | Uint8Array | string, options?: ExecutionOptions);
     get metadata(): ContractMetadata;
     get registry(): TypinkRegistry;
     get tx(): ContractApi['constructorTx'];

package/ContractDeployer.js

@@ -1,19 +1,21 @@
 import { TypinkRegistry } from './TypinkRegistry.js';
 import { ConstructorQueryExecutor } from './executor/ConstructorQueryExecutor.js';
 import { ConstructorTxExecutor } from './executor/index.js';
-import { ensureSupportContractsPallet, newProxyChain, parseRawMetadata } from './utils.js';
+import { ensurePalletPresence, ensureSupportedContractMetadataVersion, ensureValidCodeHashOrCode, newProxyChain, } from './utils/index.js';
 export class ContractDeployer {
     client;
     #metadata;
     #registry;
     #code;
     #options;
-    constructor(client, metadata, codeHashOrWasm, options) {
+    constructor(client, metadata, codeHashOrCode, options) {
         this.client = client;
-        ensureSupportContractsPallet(client);
-        this.#metadata = typeof metadata === 'string' ? parseRawMetadata(metadata) : metadata;
-        this.#registry = new TypinkRegistry(this.#metadata);
-        this.#code = codeHashOrWasm;
+        this.#metadata = (typeof metadata === 'string' ? JSON.parse(metadata) : metadata);
+        ensureSupportedContractMetadataVersion(this.metadata);
+        this.#registry = new TypinkRegistry(this.metadata);
+        ensurePalletPresence(client, this.registry);
+        ensureValidCodeHashOrCode(codeHashOrCode, this.registry);
+        this.#code = codeHashOrCode;
         this.#options = options;
     }
     get metadata() {

package/TypinkRegistry.d.ts

@@ -1,10 +1,33 @@
-import { AccountId32Like, TypeRegistry } from '@dedot/codecs';
+import { TypeId, TypeRegistry } from '@dedot/codecs';
+import * as $ from '@dedot/shape';
 import { IEventRecord } from '@dedot/types';
-import { ContractEvent, ContractMetadata } from './types/index.js';
+import { HexString } from '@dedot/utils';
+import { ContractAddress, ContractEvent, ContractMetadata } from './types/index.js';
+export interface TypinkRegistryOptions {
+    /**
+     * Get raw contract storage value given a key
+     *
+     * @param key
+     */
+    getStorage?: (key: Uint8Array | HexString) => Promise<HexString | undefined>;
+}
 export declare class TypinkRegistry extends TypeRegistry {
     #private;
-    constructor(metadata: ContractMetadata);
-    get metadata(): ContractMetadata;
-    decodeEvents(records: IEventRecord[], contract?: AccountId32Like): ContractEvent[];
-    decodeEvent(eventRecord: IEventRecord, contract?: AccountId32Like): ContractEvent;
+    readonly metadata: ContractMetadata;
+    readonly options?: TypinkRegistryOptions | undefined;
+    constructor(metadata: ContractMetadata, options?: TypinkRegistryOptions | undefined);
+    findCodec<I = unknown, O = I>(typeId: TypeId): $.Shape<I, O>;
+    /**
+     * 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: TypeId): $.AnyShape | null;
+    decodeEvents(records: IEventRecord[], contract?: ContractAddress): ContractEvent[];
+    decodeEvent(eventRecord: IEventRecord, contract?: ContractAddress): ContractEvent;
+    /**
+     * Check if the contract is Revive Compatible (ink!v6)
+     */
+    isRevive(): boolean;
 }

package/TypinkRegistry.js

@@ -1,15 +1,99 @@
 import { AccountId32, TypeRegistry } from '@dedot/codecs';
 import * as $ from '@dedot/shape';
-import { DedotError, assert, hexToU8a, stringCamelCase, stringPascalCase } from '@dedot/utils';
-import { extractContractTypes } from './utils.js';
+import { assert, DedotError, hexToU8a, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { LazyMapping, LazyObject, LazyStorageVec } from './storage/index.js';
+import { ensureSupportedContractMetadataVersion, extractContractTypes, isLazyType, KnownLazyType, } from './utils/index.js';
 export class TypinkRegistry extends TypeRegistry {
-    #metadata;
-    constructor(metadata) {
+    metadata;
+    options;
+    constructor(metadata, options) {
+        ensureSupportedContractMetadataVersion(metadata);
         super(extractContractTypes(metadata));
-        this.#metadata = 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 = isLazyType(typeDef.type.path);
+        if (lazyType === KnownLazyType.MAPPING) {
+            return this.#createLazyCodec(LazyMapping, $codec, typeDef);
+        }
+        else if (lazyType === KnownLazyType.LAZY) {
+            return this.#createLazyCodec(LazyObject, $codec, typeDef);
+        }
+        else if (lazyType === KnownLazyType.STORAGE_VEC) {
+            return this.#createLazyCodec(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 = 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
@@ -18,27 +102,35 @@ export class TypinkRegistry extends TypeRegistry {
     }
     decodeEvent(eventRecord, contract) {
         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 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 AccountId32) {
-                return emittedContract.eq(contract);
+            if (this.isRevive()) {
+                return emittedContract === contractAddress;
+            }
+            else if (emittedContract instanceof AccountId32) {
+                return emittedContract.eq(contractAddress);
             }
             else {
                 return false;
@@ -47,32 +139,51 @@ export class TypinkRegistry extends TypeRegistry {
         return true;
     }
     #decodeEventV4(eventRecord) {
-        assert(this.#metadata.version === '4', 'Invalid metadata version!');
+        assert(this.metadata.version === '4', 'Invalid metadata version!');
         assert(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
         const data = hexToU8a(eventRecord.event.palletEvent.data.data);
         const index = data.at(0);
         assert(index !== undefined, 'Unable to decode event index!');
-        const event = this.#metadata.spec.events[index];
+        const event = this.metadata.spec.events[index];
         assert(event, `Event index not found: ${index.toString()}`);
         return this.#tryDecodeEvent(event, data.subarray(1));
     }
-    #decodeEventV5(eventRecord) {
-        assert(this.#metadata.version === 5, 'Invalid metadata version!');
-        assert(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
-        const data = hexToU8a(eventRecord.event.palletEvent.data.data);
-        const signatureTopic = eventRecord.topics.at(0);
+    #detectEventMeta(signatureTopics) {
+        // Only version >= 5 metadata supports signature topics
+        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);
             assert(potentialEvents.length === 1, 'Unable to determine event!');
             eventMeta = potentialEvents[0];
         }
+        return eventMeta;
+    }
+    #decodeEventV5(eventRecord) {
+        assert(this.metadata.version === 5, 'Invalid metadata version!');
+        assert(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
+        const data = hexToU8a(eventRecord.event.palletEvent.data.data);
+        const signatureTopics = eventRecord.topics;
+        const eventMeta = this.#detectEventMeta(signatureTopics);
+        return this.#tryDecodeEvent(eventMeta, data);
+    }
+    #decodeEventV6(eventRecord) {
+        assert(this.isRevive(), 'Invalid metadata version!');
+        assert(this.#isContractEmittedEvent(eventRecord.event), 'Invalid ContractEmitted Event');
+        const eventData = eventRecord.event.palletEvent.data;
+        const data = hexToU8a(eventData.data);
+        const signatureTopics = eventData.topics;
+        const eventMeta = this.#detectEventMeta(signatureTopics);
         return this.#tryDecodeEvent(eventMeta, data);
     }
     #tryDecodeEvent(eventMeta, raw) {
@@ -88,4 +199,13 @@ export class TypinkRegistry extends TypeRegistry {
         const name = 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.'));
+    }
 }

package/cjs/Contract.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Contract = void 0;
-const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
 const TypinkRegistry_js_1 = require("./TypinkRegistry.js");
 const index_js_1 = require("./executor/index.js");
-const utils_js_1 = require("./utils.js");
+const index_js_2 = require("./utils/index.js");
 class Contract {
     client;
     #registry;
@@ -13,10 +13,13 @@ class Contract {
     #options;
     constructor(client, metadata, address, options) {
         this.client = client;
-        (0, utils_js_1.ensureSupportContractsPallet)(client);
-        this.#address = new codecs_1.AccountId32(address);
-        this.#metadata = typeof metadata === 'string' ? (0, utils_js_1.parseRawMetadata)(metadata) : metadata;
-        this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.#metadata);
+        this.#metadata = (typeof metadata === 'string' ? JSON.parse(metadata) : metadata);
+        (0, index_js_2.ensureSupportedContractMetadataVersion)(this.metadata);
+        const getStorage = this.#getStorage.bind(this);
+        this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.metadata, { getStorage });
+        (0, index_js_2.ensurePalletPresence)(client, this.registry);
+        (0, index_js_2.ensureValidContractAddress)(address, this.registry);
+        this.#address = address;
         this.#options = options;
     }
     decodeEvent(eventRecord) {
@@ -35,16 +38,48 @@ class Contract {
         return this.#registry;
     }
     get query() {
-        return (0, utils_js_1.newProxyChain)(new index_js_1.QueryExecutor(this.client, this.#registry, this.#address, this.#options));
+        return (0, index_js_2.newProxyChain)(new index_js_1.QueryExecutor(this.client, this.#registry, this.#address, this.#options));
     }
     get tx() {
-        return (0, utils_js_1.newProxyChain)(new index_js_1.TxExecutor(this.client, this.#registry, this.#address, this.#options));
+        return (0, index_js_2.newProxyChain)(new index_js_1.TxExecutor(this.client, this.#registry, this.#address, this.#options));
     }
     get events() {
-        return (0, utils_js_1.newProxyChain)(new index_js_1.EventExecutor(this.client, this.#registry, this.#address, this.#options));
+        return (0, index_js_2.newProxyChain)(new index_js_1.EventExecutor(this.client, this.#registry, this.#address, this.#options));
     }
     get options() {
         return this.#options;
     }
+    get storage() {
+        return {
+            root: async () => {
+                (0, index_js_2.ensureStorageApiSupports)(this.metadata.version);
+                const { ty, root_key } = this.metadata.storage.root;
+                const rawValue = await this.#getStorage(root_key);
+                return this.registry.findCodec(ty).tryDecode(rawValue);
+            },
+            lazy: () => {
+                (0, index_js_2.ensureStorageApiSupports)(this.metadata.version);
+                const { ty } = this.metadata.storage.root;
+                const $lazyCodec = this.registry.createLazyCodec(ty);
+                return $lazyCodec ? $lazyCodec.tryDecode('0x') : {};
+            },
+        };
+    }
+    #getStorage = async (key) => {
+        const result = await (async () => {
+            if (this.registry.isRevive()) {
+                return await this.client.call.reviveApi.getStorageVarKey(this.address, //--
+                (0, utils_1.toHex)(key));
+            }
+            else {
+                return await this.client.call.contractsApi.getStorage(this.address, //--
+                (0, utils_1.toU8a)(key));
+            }
+        })();
+        if (result.isOk) {
+            return result.value;
+        }
+        throw new utils_1.DedotError(result.err);
+    };
 }
 exports.Contract = Contract;

package/cjs/ContractDeployer.js

@@ -4,19 +4,21 @@ exports.ContractDeployer = void 0;
 const TypinkRegistry_js_1 = require("./TypinkRegistry.js");
 const ConstructorQueryExecutor_js_1 = require("./executor/ConstructorQueryExecutor.js");
 const index_js_1 = require("./executor/index.js");
-const utils_js_1 = require("./utils.js");
+const index_js_2 = require("./utils/index.js");
 class ContractDeployer {
     client;
     #metadata;
     #registry;
     #code;
     #options;
-    constructor(client, metadata, codeHashOrWasm, options) {
+    constructor(client, metadata, codeHashOrCode, options) {
         this.client = client;
-        (0, utils_js_1.ensureSupportContractsPallet)(client);
-        this.#metadata = typeof metadata === 'string' ? (0, utils_js_1.parseRawMetadata)(metadata) : metadata;
-        this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.#metadata);
-        this.#code = codeHashOrWasm;
+        this.#metadata = (typeof metadata === 'string' ? JSON.parse(metadata) : metadata);
+        (0, index_js_2.ensureSupportedContractMetadataVersion)(this.metadata);
+        this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.metadata);
+        (0, index_js_2.ensurePalletPresence)(client, this.registry);
+        (0, index_js_2.ensureValidCodeHashOrCode)(codeHashOrCode, this.registry);
+        this.#code = codeHashOrCode;
         this.#options = options;
     }
     get metadata() {
@@ -26,10 +28,10 @@ class ContractDeployer {
         return this.#registry;
     }
     get tx() {
-        return (0, utils_js_1.newProxyChain)(new index_js_1.ConstructorTxExecutor(this.client, this.#registry, this.#code, this.#options));
+        return (0, index_js_2.newProxyChain)(new index_js_1.ConstructorTxExecutor(this.client, this.#registry, this.#code, this.#options));
     }
     get query() {
-        return (0, utils_js_1.newProxyChain)(new ConstructorQueryExecutor_js_1.ConstructorQueryExecutor(this.client, this.#registry, this.#code, this.#options));
+        return (0, index_js_2.newProxyChain)(new ConstructorQueryExecutor_js_1.ConstructorQueryExecutor(this.client, this.#registry, this.#code, this.#options));
     }
     get options() {
         return this.#options;