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

package/Contract.d.ts

@@ -1,16 +1,17 @@
 import { ISubstrateClient } from '@dedot/api';
 import { IEventRecord } from '@dedot/types';
+import { SolRegistry } from './SolRegistry.js';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ContractAddress, ContractEvent, ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata } from './types/index.js';
+import { AB, ContractAddress, ContractEvent, ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata, SolAbi } 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: LooseContractMetadata | string, address: ContractAddress, options?: ExecutionOptions);
+    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: LooseContractMetadata | SolAbi | string, address: ContractAddress, options?: ExecutionOptions);
     decodeEvent(eventRecord: IEventRecord): ContractEvent;
     decodeEvents(eventRecords: IEventRecord[]): ContractEvent[];
-    get metadata(): ContractMetadata;
     get address(): ContractAddress;
-    get registry(): TypinkRegistry;
+    get metadata(): AB<ContractApi['metadataType'], ContractMetadata, SolAbi>;
+    get registry(): AB<ContractApi['metadataType'], TypinkRegistry, SolRegistry>;
     get query(): ContractApi['query'];
     get tx(): ContractApi['tx'];
     get events(): ContractApi['events'];

package/Contract.js

@@ -1,21 +1,37 @@
 import { DedotError, toHex, toU8a } from '@dedot/utils';
+import { SolRegistry } from './SolRegistry.js';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { EventExecutor, QueryExecutor, TxExecutor } from './executor/index.js';
-import { ensurePalletPresence, ensureStorageApiSupports, ensureSupportedContractMetadataVersion, ensureValidContractAddress, newProxyChain, } from './utils/index.js';
+import { SolEventExecutor, SolQueryExecutor, SolTxExecutor } from './executor/index.js';
+import { EventExecutor, QueryExecutor, TxExecutor } from './executor/ink/index.js';
+import { ensurePalletPresence, ensureStorageApiSupports, ensureSupportedContractMetadataVersion, ensureValidContractAddress, isInkAbi, isSolAbi, newProxyChain, } from './utils/index.js';
 export class Contract {
     client;
     #registry;
-    #address;
     #metadata;
+    #address;
+    #isInk = false;
     #options;
     constructor(client, metadata, address, options) {
         this.client = client;
-        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.#metadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+        if (isInkAbi(this.metadata)) {
+            this.#isInk = true;
+            ensureSupportedContractMetadataVersion(this.metadata);
+            const getStorage = this.#getStorage.bind(this);
+            // @ts-ignore
+            this.#registry = new TypinkRegistry(this.metadata, { getStorage });
+            ensurePalletPresence(client, this.registry.isRevive());
+            ensureValidContractAddress(address, this.registry.isRevive());
+        }
+        else if (isSolAbi(this.metadata)) {
+            // @ts-ignore
+            this.#registry = new SolRegistry(this.metadata);
+            ensurePalletPresence(client, true);
+            ensureValidContractAddress(address, true);
+        }
+        else {
+            throw new DedotError('Unknown metadata format (neither ink! nor Solidity ABI)');
+        }
         this.#address = address;
         this.#options = options;
     }
@@ -25,39 +41,50 @@ export class Contract {
     decodeEvents(eventRecords) {
         return this.#registry.decodeEvents(eventRecords, this.address);
     }
-    get metadata() {
-        return this.#metadata;
-    }
     get address() {
         return this.#address;
     }
+    get metadata() {
+        return this.#metadata;
+    }
     get registry() {
         return this.#registry;
     }
     get query() {
-        return newProxyChain(new QueryExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? QueryExecutor : SolQueryExecutor;
+        // @ts-ignore
+        return newProxyChain(new Executor(this.client, this.registry, this.address, this.options));
     }
     get tx() {
-        return newProxyChain(new TxExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? TxExecutor : SolTxExecutor;
+        // @ts-ignore
+        return newProxyChain(new Executor(this.client, this.registry, this.address, this.options));
     }
     get events() {
-        return newProxyChain(new EventExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? EventExecutor : SolEventExecutor;
+        // @ts-ignore
+        return newProxyChain(new Executor(this.client, this.registry, this.address, this.options));
     }
     get options() {
         return this.#options;
     }
     get storage() {
+        if (!this.#isInk) {
+            throw new DedotError('Storage API is only available for ink! contracts');
+        }
         return {
             root: async () => {
                 ensureStorageApiSupports(this.metadata.version);
                 const { ty, root_key } = this.metadata.storage.root;
                 const rawValue = await this.#getStorage(root_key);
+                // @ts-ignore
                 return this.registry.findCodec(ty).tryDecode(rawValue);
             },
             lazy: () => {
                 ensureStorageApiSupports(this.metadata.version);
                 const { ty } = this.metadata.storage.root;
                 const $lazyCodec = this.registry.createLazyCodec(ty);
+                // @ts-ignore
                 return $lazyCodec ? $lazyCodec.tryDecode('0x') : {};
             },
         };

package/ContractDeployer.d.ts

@@ -1,13 +1,14 @@
 import { ISubstrateClient } from '@dedot/api';
 import { Hash } from '@dedot/codecs';
+import { SolRegistry } from './SolRegistry.js';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata } from './types/index.js';
+import { AB, ContractMetadata, ExecutionOptions, GenericContractApi, LooseContractMetadata, SolAbi } 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: LooseContractMetadata | string, codeHashOrCode: Hash | Uint8Array | string, options?: ExecutionOptions);
-    get metadata(): ContractMetadata;
-    get registry(): TypinkRegistry;
+    constructor(client: ISubstrateClient<ContractApi['types']['ChainApi']>, metadata: AB<ContractApi['metadataType'], LooseContractMetadata, SolAbi> | string, codeHashOrCode: Hash | Uint8Array | string, options?: ExecutionOptions);
+    get metadata(): AB<ContractApi['metadataType'], ContractMetadata, SolAbi>;
+    get registry(): AB<ContractApi['metadataType'], TypinkRegistry, SolRegistry>;
     get tx(): ContractApi['constructorTx'];
     get query(): ContractApi['constructorQuery'];
     get options(): ExecutionOptions | undefined;

package/ContractDeployer.js

@@ -1,20 +1,31 @@
+import { SolRegistry } from './SolRegistry.js';
 import { TypinkRegistry } from './TypinkRegistry.js';
-import { ConstructorQueryExecutor } from './executor/ConstructorQueryExecutor.js';
-import { ConstructorTxExecutor } from './executor/index.js';
-import { ensurePalletPresence, ensureSupportedContractMetadataVersion, ensureValidCodeHashOrCode, newProxyChain, } from './utils/index.js';
+import { ConstructorQueryExecutor, ConstructorTxExecutor, SolConstructorQueryExecutor, SolConstructorTxExecutor, } from './executor/index.js';
+import { ensurePalletPresence, ensureSupportedContractMetadataVersion, ensureValidCodeHashOrCode, isInkAbi, newProxyChain, } from './utils/index.js';
 export class ContractDeployer {
     client;
+    #isInk = false;
     #metadata;
     #registry;
     #code;
     #options;
     constructor(client, metadata, codeHashOrCode, options) {
         this.client = client;
-        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.#metadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+        if (isInkAbi(this.metadata)) {
+            this.#isInk = true;
+            ensureSupportedContractMetadataVersion(this.metadata);
+            // @ts-ignore
+            this.#registry = new TypinkRegistry(this.metadata);
+            ensurePalletPresence(client, this.registry.isRevive());
+            ensureValidCodeHashOrCode(codeHashOrCode, this.registry.isRevive());
+        }
+        else {
+            // @ts-ignore
+            this.#registry = new SolRegistry(this.metadata);
+            ensurePalletPresence(client, true);
+            ensureValidCodeHashOrCode(codeHashOrCode, true);
+        }
         this.#code = codeHashOrCode;
         this.#options = options;
     }
@@ -25,10 +36,16 @@ export class ContractDeployer {
         return this.#registry;
     }
     get tx() {
-        return newProxyChain(new ConstructorTxExecutor(this.client, this.#registry, this.#code, this.#options));
+        const Executor = this.#isInk ? ConstructorTxExecutor : SolConstructorTxExecutor;
+        return newProxyChain(
+        // @ts-ignore
+        new Executor(this.client, this.registry, this.#code, this.options));
     }
     get query() {
-        return newProxyChain(new ConstructorQueryExecutor(this.client, this.#registry, this.#code, this.#options));
+        const Executor = this.#isInk ? ConstructorQueryExecutor : SolConstructorQueryExecutor;
+        return newProxyChain(
+        // @ts-ignore
+        new Executor(this.client, this.registry, this.#code, this.options));
     }
     get options() {
         return this.#options;

package/SolRegistry.d.ts

@@ -0,0 +1,22 @@
+import { IEventRecord } from '@dedot/codecs/types';
+import { LRUCache } from '@dedot/utils';
+import { ContractAddress, SolAbi, ContractEvent, SolAbiFunction, SolAbiConstructor, SolAbiEvent, SolAbiError } from './types/index.js';
+export declare class SolRegistry {
+    #private;
+    readonly abi: SolAbi;
+    readonly cache: LRUCache;
+    constructor(abi: SolAbi);
+    findAbiFunction(name: string): SolAbiFunction | undefined;
+    findTxAbiFunction(name: string): SolAbiFunction | undefined;
+    findAbiConstructor(): SolAbiConstructor;
+    findAbiEvent(name: string): SolAbiEvent | undefined;
+    findAbiError(name: string): SolAbiError | undefined;
+    decodeEvents(records: IEventRecord[], contract: ContractAddress): ContractEvent[];
+    decodeEvent(eventRecord: IEventRecord, contract: ContractAddress): {
+        name: string;
+        data: {};
+    } | {
+        name: string;
+        data?: undefined;
+    };
+}

package/SolRegistry.js

@@ -0,0 +1,64 @@
+import { assert, stringCamelCase, LRUCache } from '@dedot/utils';
+import { decodeEventLog } from 'viem/utils';
+export class SolRegistry {
+    abi;
+    cache;
+    constructor(abi) {
+        this.abi = abi;
+        this.cache = new LRUCache(500);
+    }
+    findAbiFunction(name) {
+        return this.abi.find((one) => one.type === 'function' && stringCamelCase(one.name) === name);
+    }
+    findTxAbiFunction(name) {
+        const found = this.findAbiFunction(name);
+        if (found && (found.stateMutability === 'payable' || found.stateMutability === 'nonpayable')) {
+            return found;
+        }
+        return undefined;
+    }
+    findAbiConstructor() {
+        let item = this.abi.find((a) => a.type === 'constructor');
+        return (item ||
+            {
+                inputs: [],
+                stateMutability: 'nonpayable',
+                type: 'constructor',
+            } // Fallback to default constructor
+        );
+    }
+    findAbiEvent(name) {
+        return this.abi.find((one) => one.type === 'event' && one.name === name);
+    }
+    findAbiError(name) {
+        return this.abi.find((one) => one.type === 'error' && one.name === name);
+    }
+    decodeEvents(records, contract) {
+        return records
+            .filter((eventRecord) => this.#isContractEmittedEvent(eventRecord.event, contract))
+            .map((eventRecord) => this.decodeEvent(eventRecord, contract));
+    }
+    decodeEvent(eventRecord, contract) {
+        assert(this.#isContractEmittedEvent(eventRecord.event, contract), 'Invalid ContractEmitted Event');
+        const event = eventRecord.event;
+        const signatureTopic = event.palletEvent.data.topics[0];
+        const { eventName, args: data } = decodeEventLog({
+            abi: this.abi,
+            data: event.palletEvent.data.data,
+            topics: [signatureTopic, ...event.palletEvent.data.topics],
+        });
+        return data ? { name: eventName, data } : { name: eventName };
+    }
+    #isContractEmittedEvent(event, contractAddress) {
+        const eventMatched = typeof event.palletEvent === 'object' && // --
+            event.palletEvent.name === 'ContractEmitted';
+        if (!eventMatched)
+            return false;
+        if (contractAddress) {
+            // @ts-ignore
+            const emittedContract = event.palletEvent.data?.contract;
+            return emittedContract === contractAddress;
+        }
+        return true;
+    }
+}

package/TypinkRegistry.d.ts

@@ -1,7 +1,7 @@
 import { TypeId, TypeRegistry } from '@dedot/codecs';
 import * as $ from '@dedot/shape';
 import { IEventRecord } from '@dedot/types';
-import { HexString } from '@dedot/utils';
+import { HexString, LRUCache } from '@dedot/utils';
 import { ContractAddress, ContractEvent, ContractMetadata } from './types/index.js';
 export interface TypinkRegistryOptions {
     /**
@@ -15,6 +15,7 @@ export declare class TypinkRegistry extends TypeRegistry {
     #private;
     readonly metadata: ContractMetadata;
     readonly options?: TypinkRegistryOptions | undefined;
+    readonly cache: LRUCache;
     constructor(metadata: ContractMetadata, options?: TypinkRegistryOptions | undefined);
     findCodec<I = unknown, O = I>(typeId: TypeId): $.Shape<I, O>;
     /**

package/TypinkRegistry.js

@@ -1,16 +1,18 @@
 import { AccountId32, TypeRegistry } from '@dedot/codecs';
 import * as $ from '@dedot/shape';
-import { assert, DedotError, hexToU8a, stringCamelCase, stringPascalCase } from '@dedot/utils';
+import { assert, DedotError, hexToU8a, stringCamelCase, stringPascalCase, LRUCache } 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;
     options;
+    cache;
     constructor(metadata, options) {
         ensureSupportedContractMetadataVersion(metadata);
         super(extractContractTypes(metadata));
         this.metadata = metadata;
         this.options = options;
+        this.cache = new LRUCache(500);
     }
     findCodec(typeId) {
         const types = this.metadata.types;

package/cjs/Contract.js

@@ -2,23 +2,39 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Contract = void 0;
 const utils_1 = require("@dedot/utils");
+const SolRegistry_js_1 = require("./SolRegistry.js");
 const TypinkRegistry_js_1 = require("./TypinkRegistry.js");
 const index_js_1 = require("./executor/index.js");
-const index_js_2 = require("./utils/index.js");
+const index_js_2 = require("./executor/ink/index.js");
+const index_js_3 = require("./utils/index.js");
 class Contract {
     client;
     #registry;
-    #address;
     #metadata;
+    #address;
+    #isInk = false;
     #options;
     constructor(client, metadata, address, options) {
         this.client = client;
-        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.#metadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+        if ((0, index_js_3.isInkAbi)(this.metadata)) {
+            this.#isInk = true;
+            (0, index_js_3.ensureSupportedContractMetadataVersion)(this.metadata);
+            const getStorage = this.#getStorage.bind(this);
+            // @ts-ignore
+            this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.metadata, { getStorage });
+            (0, index_js_3.ensurePalletPresence)(client, this.registry.isRevive());
+            (0, index_js_3.ensureValidContractAddress)(address, this.registry.isRevive());
+        }
+        else if ((0, index_js_3.isSolAbi)(this.metadata)) {
+            // @ts-ignore
+            this.#registry = new SolRegistry_js_1.SolRegistry(this.metadata);
+            (0, index_js_3.ensurePalletPresence)(client, true);
+            (0, index_js_3.ensureValidContractAddress)(address, true);
+        }
+        else {
+            throw new utils_1.DedotError('Unknown metadata format (neither ink! nor Solidity ABI)');
+        }
         this.#address = address;
         this.#options = options;
     }
@@ -28,39 +44,50 @@ class Contract {
     decodeEvents(eventRecords) {
         return this.#registry.decodeEvents(eventRecords, this.address);
     }
-    get metadata() {
-        return this.#metadata;
-    }
     get address() {
         return this.#address;
     }
+    get metadata() {
+        return this.#metadata;
+    }
     get registry() {
         return this.#registry;
     }
     get query() {
-        return (0, index_js_2.newProxyChain)(new index_js_1.QueryExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? index_js_2.QueryExecutor : index_js_1.SolQueryExecutor;
+        // @ts-ignore
+        return (0, index_js_3.newProxyChain)(new Executor(this.client, this.registry, this.address, this.options));
     }
     get tx() {
-        return (0, index_js_2.newProxyChain)(new index_js_1.TxExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? index_js_2.TxExecutor : index_js_1.SolTxExecutor;
+        // @ts-ignore
+        return (0, index_js_3.newProxyChain)(new Executor(this.client, this.registry, this.address, this.options));
     }
     get events() {
-        return (0, index_js_2.newProxyChain)(new index_js_1.EventExecutor(this.client, this.#registry, this.#address, this.#options));
+        const Executor = this.#isInk ? index_js_2.EventExecutor : index_js_1.SolEventExecutor;
+        // @ts-ignore
+        return (0, index_js_3.newProxyChain)(new Executor(this.client, this.registry, this.address, this.options));
     }
     get options() {
         return this.#options;
     }
     get storage() {
+        if (!this.#isInk) {
+            throw new utils_1.DedotError('Storage API is only available for ink! contracts');
+        }
         return {
             root: async () => {
-                (0, index_js_2.ensureStorageApiSupports)(this.metadata.version);
+                (0, index_js_3.ensureStorageApiSupports)(this.metadata.version);
                 const { ty, root_key } = this.metadata.storage.root;
                 const rawValue = await this.#getStorage(root_key);
+                // @ts-ignore
                 return this.registry.findCodec(ty).tryDecode(rawValue);
             },
             lazy: () => {
-                (0, index_js_2.ensureStorageApiSupports)(this.metadata.version);
+                (0, index_js_3.ensureStorageApiSupports)(this.metadata.version);
                 const { ty } = this.metadata.storage.root;
                 const $lazyCodec = this.registry.createLazyCodec(ty);
+                // @ts-ignore
                 return $lazyCodec ? $lazyCodec.tryDecode('0x') : {};
             },
         };

package/cjs/ContractDeployer.js

@@ -1,23 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractDeployer = void 0;
+const SolRegistry_js_1 = require("./SolRegistry.js");
 const TypinkRegistry_js_1 = require("./TypinkRegistry.js");
-const ConstructorQueryExecutor_js_1 = require("./executor/ConstructorQueryExecutor.js");
 const index_js_1 = require("./executor/index.js");
 const index_js_2 = require("./utils/index.js");
 class ContractDeployer {
     client;
+    #isInk = false;
     #metadata;
     #registry;
     #code;
     #options;
     constructor(client, metadata, codeHashOrCode, options) {
         this.client = client;
-        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.#metadata = typeof metadata === 'string' ? JSON.parse(metadata) : metadata;
+        if ((0, index_js_2.isInkAbi)(this.metadata)) {
+            this.#isInk = true;
+            (0, index_js_2.ensureSupportedContractMetadataVersion)(this.metadata);
+            // @ts-ignore
+            this.#registry = new TypinkRegistry_js_1.TypinkRegistry(this.metadata);
+            (0, index_js_2.ensurePalletPresence)(client, this.registry.isRevive());
+            (0, index_js_2.ensureValidCodeHashOrCode)(codeHashOrCode, this.registry.isRevive());
+        }
+        else {
+            // @ts-ignore
+            this.#registry = new SolRegistry_js_1.SolRegistry(this.metadata);
+            (0, index_js_2.ensurePalletPresence)(client, true);
+            (0, index_js_2.ensureValidCodeHashOrCode)(codeHashOrCode, true);
+        }
         this.#code = codeHashOrCode;
         this.#options = options;
     }
@@ -28,10 +39,16 @@ class ContractDeployer {
         return this.#registry;
     }
     get tx() {
-        return (0, index_js_2.newProxyChain)(new index_js_1.ConstructorTxExecutor(this.client, this.#registry, this.#code, this.#options));
+        const Executor = this.#isInk ? index_js_1.ConstructorTxExecutor : index_js_1.SolConstructorTxExecutor;
+        return (0, index_js_2.newProxyChain)(
+        // @ts-ignore
+        new Executor(this.client, this.registry, this.#code, this.options));
     }
     get query() {
-        return (0, index_js_2.newProxyChain)(new ConstructorQueryExecutor_js_1.ConstructorQueryExecutor(this.client, this.#registry, this.#code, this.#options));
+        const Executor = this.#isInk ? index_js_1.ConstructorQueryExecutor : index_js_1.SolConstructorQueryExecutor;
+        return (0, index_js_2.newProxyChain)(
+        // @ts-ignore
+        new Executor(this.client, this.registry, this.#code, this.options));
     }
     get options() {
         return this.#options;

package/cjs/SolRegistry.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SolRegistry = void 0;
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("viem/utils");
+class SolRegistry {
+    abi;
+    cache;
+    constructor(abi) {
+        this.abi = abi;
+        this.cache = new utils_1.LRUCache(500);
+    }
+    findAbiFunction(name) {
+        return this.abi.find((one) => one.type === 'function' && (0, utils_1.stringCamelCase)(one.name) === name);
+    }
+    findTxAbiFunction(name) {
+        const found = this.findAbiFunction(name);
+        if (found && (found.stateMutability === 'payable' || found.stateMutability === 'nonpayable')) {
+            return found;
+        }
+        return undefined;
+    }
+    findAbiConstructor() {
+        let item = this.abi.find((a) => a.type === 'constructor');
+        return (item ||
+            {
+                inputs: [],
+                stateMutability: 'nonpayable',
+                type: 'constructor',
+            } // Fallback to default constructor
+        );
+    }
+    findAbiEvent(name) {
+        return this.abi.find((one) => one.type === 'event' && one.name === name);
+    }
+    findAbiError(name) {
+        return this.abi.find((one) => one.type === 'error' && one.name === name);
+    }
+    decodeEvents(records, contract) {
+        return records
+            .filter((eventRecord) => this.#isContractEmittedEvent(eventRecord.event, contract))
+            .map((eventRecord) => this.decodeEvent(eventRecord, contract));
+    }
+    decodeEvent(eventRecord, contract) {
+        (0, utils_1.assert)(this.#isContractEmittedEvent(eventRecord.event, contract), 'Invalid ContractEmitted Event');
+        const event = eventRecord.event;
+        const signatureTopic = event.palletEvent.data.topics[0];
+        const { eventName, args: data } = (0, utils_2.decodeEventLog)({
+            abi: this.abi,
+            data: event.palletEvent.data.data,
+            topics: [signatureTopic, ...event.palletEvent.data.topics],
+        });
+        return data ? { name: eventName, data } : { name: eventName };
+    }
+    #isContractEmittedEvent(event, contractAddress) {
+        const eventMatched = typeof event.palletEvent === 'object' && // --
+            event.palletEvent.name === 'ContractEmitted';
+        if (!eventMatched)
+            return false;
+        if (contractAddress) {
+            // @ts-ignore
+            const emittedContract = event.palletEvent.data?.contract;
+            return emittedContract === contractAddress;
+        }
+        return true;
+    }
+}
+exports.SolRegistry = SolRegistry;

package/cjs/TypinkRegistry.js

@@ -32,11 +32,13 @@ const index_js_2 = require("./utils/index.js");
 class TypinkRegistry extends codecs_1.TypeRegistry {
     metadata;
     options;
+    cache;
     constructor(metadata, options) {
         (0, index_js_2.ensureSupportedContractMetadataVersion)(metadata);
         super((0, index_js_2.extractContractTypes)(metadata));
         this.metadata = metadata;
         this.options = options;
+        this.cache = new utils_1.LRUCache(500);
     }
     findCodec(typeId) {
         const types = this.metadata.types;