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

package/storage/LazyMapping.js

@@ -0,0 +1,18 @@
+import { concatU8a, toU8a } from '@dedot/utils';
+import { BaseLazyObject } from './BaseLazyObject.js';
+export class LazyMapping extends 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 = concatU8a(toU8a(rootKey), encodedKey);
+        const rawValue = await this.getContractStorage(storageKey);
+        if (rawValue) {
+            return $Value.tryDecode(rawValue);
+        }
+        return undefined;
+    }
+}

package/storage/LazyObject.d.ts

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

package/storage/LazyObject.js

@@ -0,0 +1,14 @@
+import { BaseLazyObject } from './BaseLazyObject.js';
+export class LazyObject extends 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;
+    }
+}

package/storage/LazyStorageVec.d.ts

@@ -0,0 +1,5 @@
+import { BaseLazyObject } from './BaseLazyObject.js';
+export declare class LazyStorageVec extends BaseLazyObject {
+    len(): Promise<number>;
+    get(index: number): Promise<unknown>;
+}

package/storage/LazyStorageVec.js

@@ -0,0 +1,27 @@
+import * as $ from '@dedot/shape';
+import { concatU8a, toU8a } from '@dedot/utils';
+import { BaseLazyObject } from './BaseLazyObject.js';
+export class LazyStorageVec extends 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 = concatU8a(toU8a(rootKey), encodedKey);
+        const rawValue = await this.getContractStorage(storageKey);
+        if (rawValue) {
+            return $Value.tryDecode(rawValue);
+        }
+        return undefined;
+    }
+}

package/storage/index.d.ts

@@ -0,0 +1,3 @@
+export * from './LazyObject.js';
+export * from './LazyMapping.js';
+export * from './LazyStorageVec.js';

package/storage/index.js

@@ -0,0 +1,3 @@
+export * from './LazyObject.js';
+export * from './LazyMapping.js';
+export * from './LazyStorageVec.js';

package/types/index.d.ts

@@ -1,10 +1,14 @@
 import { SubstrateApi } from '@dedot/api/chaintypes';
-import { AccountId32, AccountId32Like, BytesLike, Weight } from '@dedot/codecs';
-import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
-import { ContractCallMessage, ContractConstructorMessage } from './shared.js';
+import { AccountId32Like, type Bytes, BytesLike, type DispatchError, Extrinsic, type H256, type Result, Weight } from '@dedot/codecs';
+import { AnyFunc, AsyncMethod, GenericSubstrateApi, IEventRecord, ISubmittableExtrinsic, RpcVersion, Unsub, VersionedGenericSubstrateApi } from '@dedot/types';
+import { ContractAddress, ContractCallMessage, ContractConstructorMessage } from './shared.js';
 import { ContractEventV4, ContractMetadataV4 } from './v4.js';
 import { ContractEventV5, ContractMetadataV5 } from './v5.js';
+import { ContractMetadataV6 } from './v6.js';
 export * from './shared.js';
+export * from './v4.js';
+export * from './v5.js';
+export * from './v6.js';
 export type ContractEventMeta = ContractEventV4 | ContractEventV5;
 /**
  * Flags used by a contract to customize exit behaviour.
@@ -18,17 +22,61 @@ export interface GenericContractCallResult<DecodedData = any, ContractResult = a
     data: DecodedData;
     raw: ContractResult;
     flags: ReturnFlags;
+    inputData: Bytes;
 }
 export interface GenericConstructorCallResult<DecodedData = any, ContractResult = any> extends GenericContractCallResult<DecodedData, ContractResult> {
-    address: AccountId32;
+    address: ContractAddress;
+}
+export type ContractCode = {
+    type: 'Upload';
+    value: Bytes;
+} | {
+    type: 'Existing';
+    value: H256;
+};
+export type WeightV2 = {
+    refTime: bigint;
+    proofSize: bigint;
+};
+export type StorageDeposit = {
+    type: 'Refund';
+    value: bigint;
+} | {
+    type: 'Charge';
+    value: bigint;
+};
+export type ExecReturnValue = {
+    flags: {
+        bits: number;
+    };
+    data: Bytes;
+};
+export type InstantiateReturnValue = {
+    result: ExecReturnValue;
+    address: ContractAddress;
+};
+export type ContractCallResult<_ extends GenericSubstrateApi> = {
+    gasConsumed: WeightV2;
+    gasRequired: WeightV2;
+    storageDeposit: StorageDeposit;
+    debugMessage?: Bytes;
+    result: Result<ExecReturnValue, DispatchError>;
+};
+export type ContractInstantiateResult<_ extends GenericSubstrateApi> = {
+    gasConsumed: WeightV2;
+    gasRequired: WeightV2;
+    storageDeposit: StorageDeposit;
+    debugMessage?: Bytes;
+    result: Result<InstantiateReturnValue, DispatchError>;
+};
+type SubmittableExtrinsic = ISubmittableExtrinsic & Extrinsic;
+export type ContractSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic;
+export type GenericInstantiateSubmittableExtrinsic<_ extends GenericSubstrateApi> = SubmittableExtrinsic;
+export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5 | ContractMetadataV6;
+export interface LooseContractMetadata {
+    version: number | string;
+    [prop: string]: any;
 }
-export type ContractCallResult<ChainApi extends GenericSubstrateApi> = Awaited<ReturnType<ChainApi['call']['contractsApi']['call']>>;
-export type ContractInstantiateResult<ChainApi extends GenericSubstrateApi> = Awaited<ReturnType<ChainApi['call']['contractsApi']['instantiate']>>;
-export type ContractSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['call']>;
-export type InstantiateWithCodeSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['instantiateWithCode']>;
-export type InstantiateSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = ReturnType<ChainApi['tx']['contracts']['instantiate']>;
-export type GenericInstantiateSubmittableExtrinsic<ChainApi extends GenericSubstrateApi> = InstantiateSubmittableExtrinsic<ChainApi> | InstantiateWithCodeSubmittableExtrinsic<ChainApi>;
-export type ContractMetadata = ContractMetadataV4 | ContractMetadataV5;
 export type CallOptions = {
     value?: bigint;
     gasLimit?: Weight | undefined;
@@ -89,13 +137,21 @@ export interface GenericContractEvents<_ extends GenericSubstrateApi> {
     [event: string]: GenericContractEvent;
 }
 export type GenericInkLangError = 'CouldNotReadInput' | any;
+export type GenericRootStorage = any;
+export type GenericLazyStorage = any;
 export interface GenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> {
     query: GenericContractQuery<ChainApi[Rv]>;
     tx: GenericContractTx<ChainApi[Rv]>;
     constructorQuery: GenericConstructorQuery<ChainApi[Rv]>;
     constructorTx: GenericConstructorTx<ChainApi[Rv]>;
     events: GenericContractEvents<ChainApi[Rv]>;
+    storage: {
+        root(): Promise<GenericRootStorage>;
+        lazy(): GenericLazyStorage;
+    };
     types: {
+        RootStorage: GenericRootStorage;
+        LazyStorage: GenericLazyStorage;
         LangError: GenericInkLangError;
         ChainApi: ChainApi[Rv];
     };
@@ -103,3 +159,9 @@ export interface GenericContractApi<Rv extends RpcVersion = RpcVersion, ChainApi
 export interface ExecutionOptions {
     defaultCaller?: AccountId32Like;
 }
+type HasGetter<T> = T extends {
+    get: (...args: any[]) => any;
+} ? true : false;
+export type WithLazyStorage<T> = {
+    [K in keyof T as HasGetter<T[K]> extends true ? K : T[K] extends object ? keyof WithLazyStorage<T[K]> extends never ? never : K : never]: T[K] extends object ? HasGetter<T[K]> extends true ? T[K] : WithLazyStorage<T[K]> : never;
+};

package/types/index.js

@@ -1 +1,4 @@
 export * from './shared.js';
+export * from './v4.js';
+export * from './v5.js';
+export * from './v6.js';

package/types/shared.d.ts

@@ -1,20 +1,19 @@
+export type ContractAddress = string;
+export interface ContractInformation {
+    name: string;
+    version: string;
+    authors: string[];
+}
 export interface ContractSource {
     hash: string;
-    wasm?: string;
     language: string;
     compiler: string;
     build_info: BuildInfo;
 }
-export interface ContractInformation {
-    name: string;
-    version: string;
-    authors: string[];
-}
 export interface BuildInfo {
     build_mode: string;
     cargo_contract_version: string;
     rust_toolchain: string;
-    wasm_opt_settings: WasmOptSettings;
 }
 export interface WasmOptSettings {
     keep_debug_symbols: boolean;
@@ -96,17 +95,6 @@ export interface ParamInfo {
     name: string;
     type: number;
 }
-export interface ContractStorage {
-    root: {
-        layout: {
-            struct: {
-                fields: any[];
-                name: string;
-            };
-        };
-        root_key: string;
-    };
-}
 export interface ContractEventArg extends ContractMessageArg {
     docs: string[];
     indexed: boolean;

package/types/v4.d.ts

@@ -1,12 +1,18 @@
-import { ContractConstructorMessage, ContractEventArg, ContractInformation, ContractCallMessage, ContractSource, ContractStorage, ContractType, ContractTypeInfo } from './shared.js';
+import { BuildInfo, ContractCallMessage, ContractConstructorMessage, ContractEventArg, ContractInformation, ContractSource, ContractType, ContractTypeInfo, WasmOptSettings } from './shared.js';
 export interface ContractMetadataV4 {
-    source: ContractSource;
+    source: ContractSourceV4;
     contract: ContractInformation;
     spec: ContractSpecV4;
-    storage: ContractStorage;
+    storage: ContractStorageV4;
     types: ContractType[];
     version: '4';
 }
+export interface ContractSourceV4 extends ContractSource {
+    wasm?: string;
+    build_info: BuildInfo & {
+        wasm_opt_settings: WasmOptSettings;
+    };
+}
 export interface ContractSpecV4 {
     constructors: ContractConstructorMessage[];
     docs: string[];
@@ -29,3 +35,41 @@ export interface ContractEnvironmentV4 {
     maxEventTopics: number;
     timestamp: ContractTypeInfo;
 }
+export interface StructLayoutV4 {
+    name: string;
+    fields: {
+        name: string;
+        layout: AnyLayoutV4;
+    }[];
+}
+export interface LeafLayoutV4 {
+    key: string;
+    ty: number;
+}
+export interface HashLayoutV4 {
+}
+export interface ArrayLayoutV4 {
+    offset: string;
+    len: number;
+    layout: AnyLayoutV4;
+}
+export interface EnumLayoutV4 {
+    name: string;
+    dispatch_key: string;
+    variants: Record<number, StructLayoutV4>;
+}
+export interface RootLayoutV4 {
+    root_key: string;
+    layout: AnyLayoutV4;
+}
+export type AnyLayoutV4 = {
+    struct?: StructLayoutV4;
+    leaf?: LeafLayoutV4;
+    hash?: HashLayoutV4;
+    array?: ArrayLayoutV4;
+    enum?: EnumLayoutV4;
+    root?: RootLayoutV4;
+};
+export interface ContractStorageV4 {
+    root: RootLayoutV4;
+}

package/types/v5.d.ts

@@ -1,10 +1,10 @@
-import { ContractInformation, ContractSource, ContractStorage, ContractType } from './shared.js';
-import { ContractEnvironmentV4, ContractEventV4, ContractSpecV4 } from './v4.js';
+import { ContractInformation, ContractType } from './shared.js';
+import { ContractEnvironmentV4, ContractEventV4, ContractSourceV4, ContractSpecV4 } from './v4.js';
 export interface ContractMetadataV5 {
-    source: ContractSource;
+    source: ContractSourceV4;
     contract: ContractInformation;
     spec: ContractSpecV5;
-    storage: ContractStorage;
+    storage: ContractStorageV5;
     types: ContractType[];
     version: 5;
 }
@@ -19,3 +19,42 @@ export interface ContractEventV5 extends ContractEventV4 {
 export interface ContractEnvironmentV5 extends ContractEnvironmentV4 {
     staticBufferSize: number;
 }
+export interface StructLayoutV5 {
+    name: string;
+    fields: {
+        name: string;
+        layout: AnyLayoutV5;
+    }[];
+}
+export interface LeafLayoutV5 {
+    key: string;
+    ty: number;
+}
+export interface HashLayoutV5 {
+}
+export interface ArrayLayoutV5 {
+    offset: string;
+    len: number;
+    layout: AnyLayoutV5;
+}
+export interface EnumLayoutV5 {
+    name: string;
+    dispatch_key: string;
+    variants: Record<number, StructLayoutV5>;
+}
+export interface RootLayoutV5 {
+    root_key: string;
+    layout: AnyLayoutV5;
+    ty: number;
+}
+export type AnyLayoutV5 = {
+    struct?: StructLayoutV5;
+    leaf?: LeafLayoutV5;
+    hash?: HashLayoutV5;
+    array?: ArrayLayoutV5;
+    enum?: EnumLayoutV5;
+    root?: RootLayoutV5;
+};
+export interface ContractStorageV5 {
+    root: RootLayoutV5;
+}

package/types/v6.d.ts

@@ -0,0 +1,13 @@
+import { ContractInformation, ContractSource, ContractType } from './shared';
+import { ContractSpecV5, ContractStorageV5 } from './v5.js';
+export interface ContractSourceV6 extends ContractSource {
+    contract_binary?: string;
+}
+export interface ContractMetadataV6 {
+    source: ContractSourceV6;
+    contract: ContractInformation;
+    spec: ContractSpecV5;
+    storage: ContractStorageV5;
+    types: ContractType[];
+    version: 6;
+}

package/types/v6.js

@@ -0,0 +1 @@
+export {};

package/utils/address.d.ts

@@ -0,0 +1,30 @@
+import { AccountId20Like, AccountId32Like, BytesLike } from '@dedot/codecs';
+import { HexString } from '@dedot/utils';
+/**
+ * Calculate new contract's address is based on the deployer's address and a nonce
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L197-L204
+ *
+ * @param deployer
+ * @param nonce
+ */
+export declare function CREATE1(deployer: AccountId20Like, nonce: number): HexString;
+/**
+ * Calculate contract's address deterministically based on the salt, deployer's address, and the code & input data.
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L206-L219
+ *
+ * @param deployer
+ * @param code
+ * @param inputData Input data for the constructor call
+ * @param salt Salt for the deployment
+ */
+export declare function CREATE2(deployer: AccountId20Like, code: BytesLike, inputData: BytesLike, salt: BytesLike): HexString;
+/**
+ * Convert a substrate address (H256) to an evm address (H160)
+ *
+ * Ref: https://github.com/paritytech/polkadot-sdk/blob/5405e473854b139f1d0735550d90687eaf1a13f9/substrate/frame/revive/src/address.rs#L101-L113
+ *
+ * @param accountId
+ */
+export declare function toEvmAddress(accountId: AccountId32Like): HexString;

package/utils/address.js

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

package/utils/ensure.d.ts

@@ -0,0 +1,12 @@
+import { ISubstrateClient } from '@dedot/api';
+import { SubstrateApi } from '@dedot/api/chaintypes';
+import { Hash } from '@dedot/codecs';
+import { RpcVersion } from '@dedot/types';
+import { TypinkRegistry } from 'src/TypinkRegistry';
+import { ContractAddress, LooseContractMetadata } from 'src/types';
+export declare const ensureStorageApiSupports: (version: string | number) => void;
+export declare function ensurePalletPresence(client: ISubstrateClient<SubstrateApi[RpcVersion]>, registry: TypinkRegistry): void;
+export declare function ensureContractPresence(client: ISubstrateClient<SubstrateApi[RpcVersion]>, registry: TypinkRegistry, address: ContractAddress): Promise<void>;
+export declare function ensureValidContractAddress(address: ContractAddress, registry: TypinkRegistry): void;
+export declare function ensureValidCodeHashOrCode(codeHashOrCode: Hash | Uint8Array | string, registry: TypinkRegistry): void;
+export declare function ensureSupportedContractMetadataVersion(metadata: LooseContractMetadata): void;

package/utils/ensure.js

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

package/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './proxy.js';
+export * from './ensure.js';
+export * from './address.js';
+export * from './storage.js';

package/utils/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './proxy.js';
+export * from './ensure.js';
+export * from './address.js';
+export * from './storage.js';

package/utils/proxy.d.ts

@@ -0,0 +1,3 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { Executor } from 'src/executor';
+export declare function newProxyChain<ChainApi extends GenericSubstrateApi>(carrier: Executor<ChainApi>): unknown;

package/utils/proxy.js

@@ -0,0 +1,7 @@
+export function newProxyChain(carrier) {
+    return new Proxy(carrier, {
+        get(target, property) {
+            return target.doExecute(property.toString());
+        },
+    });
+}

package/utils/storage.d.ts

@@ -0,0 +1,2 @@
+import { AnyLayoutV5 } from '../types/index.js';
+export declare function findStorageRootKey(layout: AnyLayoutV5, targetId: number): string | undefined;

package/utils/storage.js

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

package/utils/types.d.ts

@@ -0,0 +1,17 @@
+import { PortableType, TypeDef } from '@dedot/codecs';
+import { ContractMetadata, ContractTypeDef, ReturnFlags } from 'src/types';
+export declare const extractContractTypes: (contractMetadata: ContractMetadata) => PortableType[];
+export declare const normalizeContractTypeDef: (def: ContractTypeDef) => TypeDef;
+export declare function normalizeLabel(label?: string): string;
+export declare function toReturnFlags(bits: number): ReturnFlags;
+export declare enum KnownLazyType {
+    LAZY = "LAZY",
+    MAPPING = "MAPPING",
+    STORAGE_VEC = "STORAGE_VEC"
+}
+/**
+ * Check if a type is lazy/non-packed storage
+ *
+ * @param typePath
+ */
+export declare function isLazyType(typePath?: string | string[] | undefined): KnownLazyType | undefined;