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

package/executor/{abstract → ink/abstract}/Executor.d.ts

@@ -1,8 +1,8 @@
 import { ISubstrateClient } from '@dedot/api';
 import { SubstrateApi } from '@dedot/api/chaintypes';
 import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
-import { TypinkRegistry } from '../../TypinkRegistry.js';
-import { ContractMessageArg, ContractMessage, ExecutionOptions, ContractMetadata } from '../../types/index.js';
+import { TypinkRegistry } from '../../../TypinkRegistry.js';
+import { ContractMessageArg, ContractMessage, ExecutionOptions, ContractMetadata } from '../../../types/index.js';
 export declare abstract class Executor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
     readonly client: ISubstrateClient<ChainApi>;
     readonly registry: TypinkRegistry;

package/executor/ink/index.d.ts

@@ -0,0 +1,6 @@
+export * from './abstract/index.js';
+export * from './TxExecutor.js';
+export * from './QueryExecutor.js';
+export * from './ConstructorTxExecutor.js';
+export * from './ConstructorQueryExecutor.js';
+export * from './EventExecutor.js';

package/executor/ink/index.js

@@ -0,0 +1,6 @@
+export * from './abstract/index.js';
+export * from './TxExecutor.js';
+export * from './QueryExecutor.js';
+export * from './ConstructorTxExecutor.js';
+export * from './ConstructorQueryExecutor.js';
+export * from './EventExecutor.js';

package/executor/sol/SolConstructorQueryExecutor.d.ts

@@ -0,0 +1,5 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { SolDeployerExecutor } from './abstract/index.js';
+export declare class SolConstructorQueryExecutor<ChainApi extends GenericSubstrateApi> extends SolDeployerExecutor<ChainApi> {
+    doExecute(_: string): any;
+}

package/executor/sol/SolConstructorQueryExecutor.js

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

package/executor/sol/SolConstructorTxExecutor.d.ts

@@ -0,0 +1,5 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { SolDeployerExecutor } from './abstract/index.js';
+export declare class SolConstructorTxExecutor<ChainApi extends GenericSubstrateApi> extends SolDeployerExecutor<ChainApi> {
+    doExecute(_: string): any;
+}

package/executor/sol/SolConstructorTxExecutor.js

@@ -0,0 +1,119 @@
+import { assert, isPvm, isUndefined, toHex, toU8a } from '@dedot/utils';
+import { encodeDeployData } from 'viem/utils';
+import { Contract } from '../../Contract.js';
+import { CREATE1, CREATE2, ensureContractPresence, ensureParamsLength, toEvmAddress } from '../../utils/index.js';
+import { SolConstructorQueryExecutor } from './SolConstructorQueryExecutor.js';
+import { SolDeployerExecutor } from './abstract/index.js';
+export class SolConstructorTxExecutor extends SolDeployerExecutor {
+    doExecute(_) {
+        const abiConstructor = this.registry.findAbiConstructor();
+        // @ts-ignore
+        const callFn = (...params) => {
+            const { inputs } = abiConstructor;
+            ensureParamsLength(inputs.length, params.length);
+            const txCallOptions = (params[inputs.length] || {});
+            const { value = 0n, gasLimit, storageDepositLimit, salt } = txCallOptions;
+            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 bytes = encodeDeployData({
+                abi: this.abi,
+                bytecode: '0x',
+                args: params.slice(0, inputs.length),
+            });
+            const client = this.client;
+            const tx = (() => {
+                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);
+                }
+            })();
+            let deployerAddress, deployerNonce;
+            const calculateContractAddress = async (result) => {
+                assert(deployerAddress, 'Deployer address Not Found');
+                const { status, dispatchError } = result;
+                const onChain = status.type === 'BestChainBlockIncluded' || status.type === 'Finalized';
+                assert(onChain, 'The deployment transaction has not yet been included in the best chain block or finalized.');
+                assert(!dispatchError, 'The deployment transaction failed to execute. Refer to the dispatch error for more information.');
+                if (salt) {
+                    let code;
+                    if (isPvm(this.code)) {
+                        code = this.code;
+                    }
+                    else {
+                        // Pull the raw code in case we're using a code hash here
+                        code = await client.query.revive.pristineCode(toHex(this.code));
+                    }
+                    assert(code, 'Contract code binary not found');
+                    return CREATE2(toEvmAddress(deployerAddress), // --
+                    code, bytes, salt);
+                }
+                else {
+                    return CREATE1(toEvmAddress(deployerAddress), // --
+                    deployerNonce);
+                }
+            };
+            tx.withHooks({
+                beforeSign: async (tx, signerAddress) => {
+                    // Set data for next hooks
+                    deployerAddress = signerAddress;
+                    if (!salt) {
+                        deployerNonce = await client.call.accountNonceApi.accountNonce(deployerAddress);
+                    }
+                    const callParams = { ...tx.call.palletCall.params };
+                    const hasGasLimit = !!callParams.gasLimit;
+                    const hasStorageDepositLimit = !!callParams.storageDepositLimit;
+                    // Check if current tx provide gas limit and storage deposit limit
+                    // If not, we need to do a dry run to get the actual value
+                    const needsDryRun = !hasGasLimit || !hasStorageDepositLimit;
+                    if (!needsDryRun)
+                        return;
+                    const executor = new SolConstructorQueryExecutor(this.client, // --
+                    this.registry, this.code, {
+                        defaultCaller: signerAddress,
+                        ...this.options,
+                    });
+                    const { raw: { gasRequired, storageDeposit }, } = await executor.doExecute('new')(...params);
+                    // Replace the params with gas limit and storage deposit limit
+                    if (!hasGasLimit) {
+                        callParams.gasLimit = gasRequired;
+                    }
+                    if (!hasStorageDepositLimit) {
+                        callParams.storageDepositLimit = storageDeposit.value;
+                    }
+                    const newCall = { ...tx.call };
+                    newCall.palletCall.params = callParams;
+                    tx.call = newCall;
+                },
+                transformResult: (result) => {
+                    let cachedAddress;
+                    const contractAddress = async () => {
+                        if (cachedAddress)
+                            return cachedAddress;
+                        cachedAddress = await calculateContractAddress(result);
+                        return cachedAddress;
+                    };
+                    const contract = async (overrideOptions) => {
+                        const address = await contractAddress();
+                        // Check if the contract is existed on chain or not!
+                        await ensureContractPresence(client, true, address);
+                        return new Contract(client, // --
+                        this.abi, address, {
+                            defaultCaller: deployerAddress,
+                            ...this.options,
+                            ...overrideOptions,
+                        });
+                    };
+                    Object.assign(result, {
+                        contractAddress,
+                        contract,
+                    });
+                    return result;
+                },
+            });
+            return tx;
+        };
+        callFn.meta = abiConstructor;
+        return callFn;
+    }
+}

package/executor/sol/SolEventExecutor.d.ts

@@ -0,0 +1,6 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { GenericContractEvent } from '../../types/index.js';
+import { SolContractExecutor } from './abstract/index.js';
+export declare class SolEventExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+    doExecute(eventName: string): GenericContractEvent<string, any, 'sol'>;
+}

package/executor/sol/SolEventExecutor.js

@@ -0,0 +1,53 @@
+import { isEventRecord } from '@dedot/api';
+import { assert } from '@dedot/utils';
+import { SolContractExecutor } from './abstract/index.js';
+export class SolEventExecutor extends SolContractExecutor {
+    doExecute(eventName) {
+        const abiEvent = this.registry.findAbiEvent(eventName);
+        assert(abiEvent, `Abi item not found: ${eventName}`);
+        const is = (event) => {
+            if (isEventRecord(event)) {
+                try {
+                    event = this.registry.decodeEvent(event, this.address);
+                }
+                catch {
+                    return false;
+                }
+            }
+            return event.name === eventName;
+        };
+        const find = (events) => {
+            if (!events || events.length === 0)
+                return undefined;
+            if (isEventRecord(events[0])) {
+                return this.registry.decodeEvents(events, this.address).find(is);
+            }
+            else {
+                return events.find(is);
+            }
+        };
+        const filter = (events) => {
+            if (isEventRecord(events[0])) {
+                return this.registry.decodeEvents(events, this.address).filter(is);
+            }
+            else {
+                return events.filter(is);
+            }
+        };
+        const watch = (callback) => {
+            return this.client.query.system.events((records) => {
+                const events = filter(records);
+                if (events.length === 0)
+                    return;
+                callback(filter(records));
+            });
+        };
+        return {
+            is,
+            find,
+            filter,
+            meta: abiEvent,
+            watch,
+        };
+    }
+}

package/executor/sol/SolQueryExecutor.d.ts

@@ -0,0 +1,5 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { SolContractExecutor } from './abstract/SolContractExecutor.js';
+export declare class SolQueryExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+    doExecute(name: string): any;
+}

package/executor/sol/SolQueryExecutor.js

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

package/executor/sol/SolTxExecutor.d.ts

@@ -0,0 +1,5 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { SolContractExecutor } from './abstract/SolContractExecutor.js';
+export declare class SolTxExecutor<ChainApi extends GenericSubstrateApi> extends SolContractExecutor<ChainApi> {
+    doExecute(name: string): any;
+}

package/executor/sol/SolTxExecutor.js

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

package/executor/sol/abstract/SolContractExecutor.d.ts

@@ -0,0 +1,9 @@
+import { ISubstrateClient } from '@dedot/api';
+import { GenericSubstrateApi } from '@dedot/types';
+import { SolRegistry } from '../../../SolRegistry.js';
+import { ContractAddress, ExecutionOptions } from '../../../types/index.js';
+import { SolExecutor } from './SolExecutor.js';
+export declare abstract class SolContractExecutor<ChainApi extends GenericSubstrateApi> extends SolExecutor<ChainApi> {
+    readonly address: ContractAddress;
+    constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, address: ContractAddress, options?: ExecutionOptions);
+}

package/executor/sol/abstract/SolContractExecutor.js

@@ -0,0 +1,8 @@
+import { SolExecutor } from './SolExecutor.js';
+export class SolContractExecutor extends SolExecutor {
+    address;
+    constructor(client, registry, address, options) {
+        super(client, registry, options);
+        this.address = address;
+    }
+}

package/executor/sol/abstract/SolDeployerExecutor.d.ts

@@ -0,0 +1,11 @@
+import { ISubstrateClient } from '@dedot/api';
+import { Hash } from '@dedot/codecs';
+import { GenericSubstrateApi } from '@dedot/types';
+import { HexString } from '@dedot/utils';
+import { SolRegistry } from '../../../SolRegistry.js';
+import { ExecutionOptions } from '../../../types/index.js';
+import { SolExecutor } from './SolExecutor.js';
+export declare abstract class SolDeployerExecutor<ChainApi extends GenericSubstrateApi> extends SolExecutor<ChainApi> {
+    readonly code: Hash | Uint8Array | HexString | string;
+    constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, code: Hash | Uint8Array | HexString | string, options?: ExecutionOptions);
+}

package/executor/sol/abstract/SolDeployerExecutor.js

@@ -0,0 +1,8 @@
+import { SolExecutor } from './SolExecutor.js';
+export class SolDeployerExecutor extends SolExecutor {
+    code;
+    constructor(client, registry, code, options) {
+        super(client, registry, options);
+        this.code = code;
+    }
+}

package/executor/sol/abstract/SolExecutor.d.ts

@@ -0,0 +1,13 @@
+import { ISubstrateClient } from '@dedot/api';
+import { SubstrateApi } from '@dedot/api/chaintypes';
+import { GenericSubstrateApi, RpcVersion } from '@dedot/types';
+import { SolRegistry } from '../../../SolRegistry.js';
+import { ExecutionOptions, SolAbi } from '../../../types/index.js';
+export declare abstract class SolExecutor<ChainApi extends GenericSubstrateApi = SubstrateApi[RpcVersion]> {
+    readonly client: ISubstrateClient<ChainApi>;
+    readonly registry: SolRegistry;
+    readonly options: ExecutionOptions;
+    protected constructor(client: ISubstrateClient<ChainApi>, registry: SolRegistry, options?: ExecutionOptions);
+    get abi(): SolAbi;
+    abstract doExecute(...paths: string[]): unknown;
+}

package/executor/sol/abstract/SolExecutor.js

@@ -0,0 +1,13 @@
+export class SolExecutor {
+    client;
+    registry;
+    options;
+    constructor(client, registry, options = {}) {
+        this.client = client;
+        this.registry = registry;
+        this.options = options;
+    }
+    get abi() {
+        return this.registry.abi;
+    }
+}

package/executor/sol/abstract/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SolExecutor.js';
+export * from './SolDeployerExecutor.js';
+export * from './SolContractExecutor.js';

package/executor/sol/abstract/index.js

@@ -0,0 +1,3 @@
+export * from './SolExecutor.js';
+export * from './SolDeployerExecutor.js';
+export * from './SolContractExecutor.js';

package/executor/sol/index.d.ts

@@ -0,0 +1,6 @@
+export * from './SolTxExecutor.js';
+export * from './SolQueryExecutor.js';
+export * from './SolConstructorTxExecutor.js';
+export * from './SolConstructorQueryExecutor.js';
+export * from './SolEventExecutor.js';
+export * from './abstract/index.js';

package/executor/sol/index.js

@@ -0,0 +1,6 @@
+export * from './SolTxExecutor.js';
+export * from './SolQueryExecutor.js';
+export * from './SolConstructorTxExecutor.js';
+export * from './SolConstructorQueryExecutor.js';
+export * from './SolEventExecutor.js';
+export * from './abstract/index.js';

package/package.json

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

package/storage/BaseLazyObject.d.ts

@@ -1,6 +1,6 @@
 import { HexString } from '@dedot/utils';
 import { TypinkRegistry } from 'src/TypinkRegistry';
-import { ContractType } from 'src/types';
+import { ContractType } from '../types/index.js';
 export declare abstract class BaseLazyObject {
     readonly typeDef: ContractType;
     readonly registry: TypinkRegistry;