@dedot/api 0.0.1-alpha.32

package/json-rpc/group/ChainHead/index.js

@@ -0,0 +1,2 @@
+export * from './error.js';
+export * from './ChainHead.js';

package/json-rpc/group/ChainSpec.d.ts

@@ -0,0 +1,10 @@
+import { Properties } from '@dedot/types/json-rpc';
+import { HexString } from '@dedot/utils';
+import { IJsonRpcClient } from '../../types.js';
+import { JsonRpcGroup, JsonRpcGroupOptions } from './JsonRpcGroup.js';
+export declare class ChainSpec extends JsonRpcGroup {
+    constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    chainName(): Promise<string>;
+    genesisHash(): Promise<HexString>;
+    properties(): Promise<Properties>;
+}

package/json-rpc/group/ChainSpec.js

@@ -0,0 +1,15 @@
+import { JsonRpcGroup } from './JsonRpcGroup.js';
+export class ChainSpec extends JsonRpcGroup {
+    constructor(client, options) {
+        super(client, { prefix: 'chainSpec', supportedVersions: ['unstable', 'v1'], ...options });
+    }
+    async chainName() {
+        return this.send('chainName');
+    }
+    async genesisHash() {
+        return this.send('genesisHash');
+    }
+    async properties() {
+        return this.send('properties');
+    }
+}

package/json-rpc/group/JsonRpcGroup.d.ts

@@ -0,0 +1,74 @@
+import { EventEmitter } from '@dedot/utils';
+import { IJsonRpcClient } from '../../types.js';
+export type JsonRpcGroupVersion = 'unstable' | `v${number}`;
+export interface JsonRpcGroupOptions {
+    /**
+     * Prefix of the json-rpc group.
+     * E.g: chainHead, chainSpec, archive, etc.
+     *
+     * According to JSON-RPC v2 Spec: https://paritytech.github.io/json-rpc-interface-spec/grouping-functions-and-node-capabilities.html#grouping-functions-and-node-capabilities
+     *
+     * Note: The prefix should not contain any `_` character.
+     */
+    prefix: string;
+    /**
+     * By default, the version is automatically detected from the available rpc-methods.
+     * If a fixed version is provided, it will be forced to use instead.
+     */
+    fixedVersion?: JsonRpcGroupVersion;
+    /**
+     * List of rpc-methods to use for version detection.
+     * If not provided, the list will be fetched from the node/server.
+     * This is helpful when the node does not support `rpc_methods` method
+     * Or if we want to share the same rpc-methods list across multiple groups.
+     */
+    rpcMethods?: string[];
+    /**
+     * List of supported versions.
+     * If provided, the detected version must be in this list else an error will be thrown.
+     * This is helpful when we want to verify behaviour of new version before using/support it.
+     * If not provided, any detected version will be used.
+     */
+    supportedVersions?: JsonRpcGroupVersion[];
+}
+/**
+ * @name JsonRpcGroup
+ * A group of json-rpc methods with a common prefix.
+ *
+ * JSON-RPC V2: https://paritytech.github.io/json-rpc-interface-spec/grouping-functions-and-node-capabilities.html#grouping-functions-and-node-capabilities
+ */
+export declare class JsonRpcGroup<Event extends string = string> extends EventEmitter<Event> {
+    #private;
+    client: IJsonRpcClient;
+    options: JsonRpcGroupOptions;
+    constructor(client: IJsonRpcClient, options: JsonRpcGroupOptions);
+    /**
+     * Check if the group is supported by the connected JSON-RPC server.
+     */
+    supported(): Promise<boolean>;
+    /**
+     * Send a json-rpc request, note the method should not contain the prefix and version parts.
+     *
+     * @example
+     * ```typescript
+     * const client = await JsonRpcClient.new('wss://rpc.polkadot.io');
+     * const achieve = new JsonRpcGroup(client, { prefix: 'archive', supportedVersions: ['unstable'] });
+     *
+     * const finalizedHeight = await achieve.send<number>('finalizedHeight'); // sending archive_unstable_finalizedHeight
+     * console.log(finalizedHeight);
+     * ```
+     *
+     * @param method
+     * @param params
+     */
+    send<T = any>(method: string, ...params: any[]): Promise<T>;
+    /**
+     * The prefix of the group
+     */
+    get prefix(): string;
+    /**
+     * Detect & return the version of the group.
+     * This will be used to construct the json-rpc method name.
+     */
+    version(): Promise<JsonRpcGroupVersion>;
+}

package/json-rpc/group/JsonRpcGroup.js

@@ -0,0 +1,85 @@
+import { EventEmitter } from '@dedot/utils';
+/**
+ * @name JsonRpcGroup
+ * A group of json-rpc methods with a common prefix.
+ *
+ * JSON-RPC V2: https://paritytech.github.io/json-rpc-interface-spec/grouping-functions-and-node-capabilities.html#grouping-functions-and-node-capabilities
+ */
+export class JsonRpcGroup extends EventEmitter {
+    client;
+    options;
+    #detectedVersion;
+    constructor(client, options) {
+        super();
+        this.client = client;
+        this.options = options;
+    }
+    /**
+     * Check if the group is supported by the connected JSON-RPC server.
+     */
+    async supported() {
+        try {
+            const detectedVersion = await this.#detectVersion();
+            const { supportedVersions } = this.options;
+            // if there aren't any specific supported versions, then any detected version is supported
+            if (!supportedVersions || supportedVersions.length === 0)
+                return true;
+            return supportedVersions.includes(detectedVersion);
+        }
+        catch { }
+        return false;
+    }
+    /**
+     * Send a json-rpc request, note the method should not contain the prefix and version parts.
+     *
+     * @example
+     * ```typescript
+     * const client = await JsonRpcClient.new('wss://rpc.polkadot.io');
+     * const achieve = new JsonRpcGroup(client, { prefix: 'archive', supportedVersions: ['unstable'] });
+     *
+     * const finalizedHeight = await achieve.send<number>('finalizedHeight'); // sending archive_unstable_finalizedHeight
+     * console.log(finalizedHeight);
+     * ```
+     *
+     * @param method
+     * @param params
+     */
+    async send(method, ...params) {
+        const rpcMethod = `${this.prefix}_${await this.version()}_${method}`;
+        return this.client.rpc[rpcMethod](...params);
+    }
+    /**
+     * The prefix of the group
+     */
+    get prefix() {
+        return this.options.prefix;
+    }
+    /**
+     * Detect & return the version of the group.
+     * This will be used to construct the json-rpc method name.
+     */
+    async version() {
+        const { fixedVersion, supportedVersions } = this.options;
+        if (fixedVersion)
+            return fixedVersion;
+        const detectedVersion = await this.#detectVersion();
+        if (supportedVersions && supportedVersions.length > 0 && !supportedVersions.includes(detectedVersion)) {
+            throw new Error(`Detected version ${detectedVersion} is not supported`);
+        }
+        return detectedVersion;
+    }
+    async #detectVersion() {
+        if (!this.#detectedVersion) {
+            this.#detectedVersion = await this.#doDetectVersion();
+        }
+        return this.#detectedVersion;
+    }
+    async #doDetectVersion() {
+        const rpcMethods = this.options.rpcMethods || (await this.client.rpc.rpc_methods()).methods;
+        const prefixedMethods = rpcMethods.filter((method) => method.startsWith(`${this.prefix}_`));
+        if (prefixedMethods.length === 0) {
+            throw new Error(`No methods found with prefix ${this.prefix}`);
+        }
+        return prefixedMethods[0].split('_')[1];
+    }
+}

package/json-rpc/group/Transaction.d.ts

@@ -0,0 +1,11 @@
+import { Unsub } from '@dedot/types';
+import { OperationId } from '@dedot/types/json-rpc';
+import { HexString } from '@dedot/utils';
+import { IJsonRpcClient, TxBroadcaster } from '../../types.js';
+import { JsonRpcGroup, JsonRpcGroupOptions } from './JsonRpcGroup.js';
+export declare class Transaction extends JsonRpcGroup implements TxBroadcaster {
+    constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    broadcastTx(tx: HexString): Promise<Unsub>;
+    broadcast(tx: string): Promise<OperationId>;
+    stop(operationId: OperationId): Promise<void>;
+}

package/json-rpc/group/Transaction.js

@@ -0,0 +1,21 @@
+import { assert } from '@dedot/utils';
+import { JsonRpcGroup } from './JsonRpcGroup.js';
+export class Transaction extends JsonRpcGroup {
+    constructor(client, options) {
+        super(client, { prefix: 'transaction', supportedVersions: ['unstable', 'v1'], ...options });
+    }
+    async broadcastTx(tx) {
+        const operationId = await this.broadcast(tx);
+        return () => {
+            return this.stop(operationId);
+        };
+    }
+    async broadcast(tx) {
+        const operationId = await this.send('broadcast', tx);
+        assert(operationId, 'Maximum number of broadcasted transactions has been reached');
+        return operationId;
+    }
+    stop(operationId) {
+        return this.send('stop', operationId);
+    }
+}

package/json-rpc/group/TransactionWatch.d.ts

@@ -0,0 +1,10 @@
+import { Callback, Unsub } from '@dedot/types';
+import { TransactionWatchEvent } from '@dedot/types/json-rpc';
+import { HexString } from '@dedot/utils';
+import { IJsonRpcClient, TxBroadcaster } from '../../types.js';
+import { JsonRpcGroup, JsonRpcGroupOptions } from './JsonRpcGroup.js';
+export declare class TransactionWatch extends JsonRpcGroup implements TxBroadcaster {
+    constructor(client: IJsonRpcClient, options?: Partial<JsonRpcGroupOptions>);
+    broadcastTx(tx: HexString): Promise<Unsub>;
+    submitAndWatch(tx: HexString, callback: Callback<TransactionWatchEvent>): Promise<Unsub>;
+}

package/json-rpc/group/TransactionWatch.js

@@ -0,0 +1,13 @@
+import { noop } from '@dedot/utils';
+import { JsonRpcGroup } from './JsonRpcGroup.js';
+export class TransactionWatch extends JsonRpcGroup {
+    constructor(client, options) {
+        super(client, { prefix: 'transactionWatch', supportedVersions: ['unstable'], ...options });
+    }
+    broadcastTx(tx) {
+        return this.submitAndWatch(tx, noop);
+    }
+    async submitAndWatch(tx, callback) {
+        return this.send('submitAndWatch', tx, callback);
+    }
+}

package/json-rpc/group/index.d.ts

@@ -0,0 +1,5 @@
+export * from './JsonRpcGroup.js';
+export * from './ChainSpec.js';
+export * from './Transaction.js';
+export * from './TransactionWatch.js';
+export * from './ChainHead/index.js';

package/json-rpc/group/index.js

@@ -0,0 +1,5 @@
+export * from './JsonRpcGroup.js';
+export * from './ChainSpec.js';
+export * from './Transaction.js';
+export * from './TransactionWatch.js';
+export * from './ChainHead/index.js';

package/json-rpc/index.d.ts

@@ -0,0 +1,4 @@
+export * from './subscriptionsInfo.js';
+export * from './scaledResponses.js';
+export * from './JsonRpcClient.js';
+export * from './group/index.js';

package/json-rpc/index.js

@@ -0,0 +1,4 @@
+export * from './subscriptionsInfo.js';
+export * from './scaledResponses.js';
+export * from './JsonRpcClient.js';
+export * from './group/index.js';

package/json-rpc/scaledResponses.d.ts

@@ -0,0 +1,2 @@
+import { AnyShape } from '@dedot/shape';
+export declare const scaledResponses: Record<string, AnyShape>;

package/json-rpc/scaledResponses.js

@@ -0,0 +1,12 @@
+import { $ApplyExtrinsicResult, $Header, $Metadata, $SignedBlock, $TransactionStatus, $VersionedFinalityProof, } from '@dedot/codecs';
+export const scaledResponses = {
+    system_dryRun: $ApplyExtrinsicResult,
+    state_getMetadata: $Metadata,
+    chain_getHeader: $Header,
+    chain_getBlock: $SignedBlock,
+    chain_subscribeAllHeads: $Header,
+    chain_subscribeNewHeads: $Header,
+    chain_subscribeFinalizedHeads: $Header,
+    author_submitAndWatchExtrinsic: $TransactionStatus,
+    beefy_subscribeJustifications: $VersionedFinalityProof,
+};

package/json-rpc/subscriptionsInfo.d.ts

@@ -0,0 +1,2 @@
+import { SubscriptionsInfo } from '../types.js';
+export declare const subscriptionsInfo: SubscriptionsInfo;

package/json-rpc/subscriptionsInfo.js

@@ -0,0 +1,17 @@
+export const subscriptionsInfo = {
+    author_submitAndWatchExtrinsic: ['author_extrinsicUpdate', 'author_unwatchExtrinsic'],
+    state_subscribeRuntimeVersion: ['state_runtimeVersion', 'state_unsubscribeRuntimeVersion'],
+    state_subscribeStorage: ['state_storage', 'state_unsubscribeStorage'],
+    chain_subscribeAllHeads: ['chain_allHead', 'chain_unsubscribeAllHeads'],
+    chain_subscribeNewHeads: ['chain_newHead', 'chain_unsubscribeNewHeads'],
+    chain_subscribeFinalizedHeads: ['chain_finalizedHead', 'chain_unsubscribeFinalizedHeads'],
+    grandpa_subscribeJustifications: ['grandpa_justifications', 'grandpa_unsubscribeJustifications'],
+    beefy_subscribeJustifications: ['beefy_justifications', 'beefy_unsubscribeJustifications'],
+    chainHead_unstable_follow: ['chainHead_unstable_followEvent', 'chainHead_unstable_unfollow'],
+    chainHead_v1_follow: ['chainHead_v1_followEvent', 'chainHead_v1_unfollow'],
+    transactionWatch_unstable_submitAndWatch: [
+        'transactionWatch_unstable_watchEvent',
+        'transactionWatch_unstable_unwatch',
+    ],
+    transactionWatch_v1_submitAndWatch: ['transactionWatch_v1_watchEvent', 'transactionWatch_v1_unwatch'],
+};

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@dedot/api",
+  "version": "0.0.1-alpha.32",
+  "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
+  "author": "Thang X. Vu <thang@coongcrafts.io>",
+  "homepage": "https://github.com/dedotdev/dedot",
+  "repository": {
+    "directory": "packages/api",
+    "type": "git",
+    "url": "https://github.com/dedotdev/dedot.git"
+  },
+  "main": "./cjs/index.js",
+  "type": "module",
+  "sideEffects": false,
+  "dependencies": {
+    "@dedot/codecs": "0.0.1-alpha.32",
+    "@dedot/providers": "0.0.1-alpha.32",
+    "@dedot/runtime-specs": "0.0.1-alpha.32",
+    "@dedot/shape": "0.0.1-alpha.32",
+    "@dedot/storage": "0.0.1-alpha.32",
+    "@dedot/types": "0.0.1-alpha.32",
+    "@dedot/utils": "0.0.1-alpha.32"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
+    "clean": "rm -rf ./dist && rm -rf ./tsconfig.tsbuildinfo ./tsconfig.build.tsbuildinfo",
+    "test": "vitest --watch=false"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./cjs/index.js",
+      "default": "./index.js"
+    },
+    "./chaintypes": {
+      "types": "./chaintypes/index.d.ts",
+      "import": "./chaintypes/index.js",
+      "require": "./cjs/chaintypes/index.js",
+      "default": "./chaintypes/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@polkadot/types": "^11.0.2"
+  },
+  "gitHead": "43501104eee360a19ae18a70fe506e16d9357835",
+  "module": "./index.js",
+  "types": "./index.d.ts"
+}

package/proxychain.d.ts

@@ -0,0 +1,14 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './executor/index.js';
+export interface Carrier<ChainApi extends GenericSubstrateApi> {
+    executor: Executor<ChainApi>;
+    chain?: string[];
+}
+/**
+ * Create a chain of proxy objects
+ *
+ * @param carrier
+ * @param currentLevel
+ * @param maxLevel
+ */
+export declare const newProxyChain: <ChainApi extends GenericSubstrateApi<import("@dedot/types").RpcVersion>>(carrier: Carrier<ChainApi>, currentLevel?: number, maxLevel?: number) => unknown;

package/proxychain.js

@@ -0,0 +1,23 @@
+/**
+ * Create a chain of proxy objects
+ *
+ * @param carrier
+ * @param currentLevel
+ * @param maxLevel
+ */
+export const newProxyChain = (carrier, currentLevel = 1, maxLevel = 3) => {
+    const { executor, chain = [] } = carrier;
+    if (currentLevel === maxLevel) {
+        return executor.execute(...chain);
+    }
+    return new Proxy(carrier, {
+        get(target, property, receiver) {
+            if (!target.chain) {
+                target.chain = [];
+            }
+            const { chain } = target;
+            chain.push(property.toString());
+            return newProxyChain(target, currentLevel + 1, maxLevel);
+        },
+    });
+};

package/storage/QueryableStorage.d.ts

@@ -0,0 +1,35 @@
+import { PortableRegistry, PalletDefLatest, StorageDataLike, StorageEntryLatest, StorageKey, PrefixedStorageKey } from '@dedot/codecs';
+/**
+ * @name QueryableStorage
+ * @description A helper to encode key & decode value for a storage entry
+ */
+export declare class QueryableStorage {
+    #private;
+    readonly registry: PortableRegistry;
+    readonly palletName: string;
+    readonly storageItem: string;
+    readonly pallet: PalletDefLatest;
+    readonly storageEntry: StorageEntryLatest;
+    constructor(registry: PortableRegistry, palletName: string, storageItem: string);
+    get prefixKey(): PrefixedStorageKey;
+    get prefixKeyAsU8a(): Uint8Array;
+    /**
+     * Encode plain key input to raw/bytes storage key
+     *
+     * @param keyInput
+     */
+    encodeKey(keyInput?: any): StorageKey;
+    /**
+     * Decode storage key to plain key input
+     * Only storage keys that hashed by `twox64Concat`, `blake2_128Concat`, or `identity` can be decoded
+     *
+     * @param key
+     */
+    decodeKey(key: StorageKey): any;
+    /**
+     * Decode raw/bytes storage data to plain value
+     *
+     * @param raw
+     */
+    decodeValue(raw?: StorageDataLike | null): any;
+}

package/storage/QueryableStorage.js

@@ -0,0 +1,157 @@
+import { $StorageData, } from '@dedot/codecs';
+import { assert, HASHERS, hexAddPrefix, UnknownApiError } from '@dedot/utils';
+import { xxhashAsU8a, hexToU8a, stringCamelCase, concatU8a, u8aToHex } from '@dedot/utils';
+// https://github.com/polkadot-js/api/blob/0982f68507942c5bf6f751f662804344e211b289/packages/types/src/primitive/StorageKey.ts#L29-L38
+const HASHER_INFO = {
+    blake2_128: [16, false],
+    blake2_256: [32, false],
+    blake2_128Concat: [16, true],
+    twox128: [16, false],
+    twox256: [32, false],
+    twox64Concat: [8, true],
+    identity: [0, true],
+};
+/**
+ * @name QueryableStorage
+ * @description A helper to encode key & decode value for a storage entry
+ */
+export class QueryableStorage {
+    registry;
+    palletName;
+    storageItem;
+    pallet;
+    storageEntry;
+    constructor(registry, palletName, storageItem) {
+        this.registry = registry;
+        this.palletName = palletName;
+        this.storageItem = storageItem;
+        this.pallet = this.#getPallet();
+        this.storageEntry = this.#getStorageEntry();
+    }
+    get prefixKey() {
+        return u8aToHex(this.prefixKeyAsU8a);
+    }
+    get prefixKeyAsU8a() {
+        const palletNameHash = xxhashAsU8a(this.pallet.name, 128);
+        const storageItemHash = xxhashAsU8a(this.storageEntry.name, 128);
+        return concatU8a(palletNameHash, storageItemHash);
+    }
+    #getStorageMapInfo(type) {
+        assert(type.tag === 'Map');
+        const { hashers, keyTypeId } = type.value;
+        let keyTypeIds = [keyTypeId];
+        if (hashers.length > 1) {
+            const { type } = this.registry.findType(keyTypeId);
+            assert(type.tag === 'Tuple', 'Key type should be a tuple!');
+            keyTypeIds = type.value.fields;
+        }
+        return { hashers, keyTypeIds };
+    }
+    /**
+     * Encode plain key input to raw/bytes storage key
+     *
+     * @param keyInput
+     */
+    encodeKey(keyInput) {
+        const { type } = this.storageEntry;
+        if (type.tag === 'Plain') {
+            return this.prefixKey;
+        }
+        else if (type.tag === 'Map') {
+            const { hashers, keyTypeIds } = this.#getStorageMapInfo(type);
+            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length);
+            const keyParts = keyTypeIds.map((keyId, index) => {
+                const input = extractedInputs[index];
+                const hasher = HASHERS[hashers[index]];
+                const $keyCodec = this.registry.findCodec(keyId);
+                return hasher($keyCodec.tryEncode(input));
+            });
+            return u8aToHex(concatU8a(this.prefixKeyAsU8a, ...keyParts));
+        }
+        throw Error(`Invalid storage entry type: ${type}`);
+    }
+    /**
+     * Decode storage key to plain key input
+     * Only storage keys that hashed by `twox64Concat`, `blake2_128Concat`, or `identity` can be decoded
+     *
+     * @param key
+     */
+    decodeKey(key) {
+        const { type } = this.storageEntry;
+        if (type.tag === 'Plain') {
+            return;
+        }
+        else if (type.tag === 'Map') {
+            const prefix = this.prefixKey;
+            if (!key.startsWith(prefix)) {
+                throw new Error(`Storage key does not match this storage entry (${this.palletName}.${this.storageItem})`);
+            }
+            const { hashers, keyTypeIds } = this.#getStorageMapInfo(type);
+            let keyData = hexToU8a(hexAddPrefix(key.slice(prefix.length)));
+            const results = keyTypeIds.map((keyId, index) => {
+                const [hashLen, canDecode] = HASHER_INFO[hashers[index]];
+                if (!canDecode)
+                    throw new Error('Cannot decode storage key');
+                const $keyCodec = this.registry.findCodec(keyId);
+                keyData = keyData.slice(hashLen);
+                const result = $keyCodec.tryDecode(keyData);
+                const encoded = $keyCodec.tryEncode(result);
+                keyData = keyData.slice(encoded.length);
+                return result;
+            });
+            return hashers.length > 1 ? results : results[0];
+        }
+        throw Error(`Invalid storage entry type: ${type}`);
+    }
+    /**
+     * Decode raw/bytes storage data to plain value
+     *
+     * @param raw
+     */
+    decodeValue(raw) {
+        const { modifier, type: { value: { valueTypeId }, }, default: defaultValue, } = this.storageEntry;
+        if (raw === null || raw === undefined) {
+            if (modifier === 'Optional') {
+                return undefined;
+            }
+            else if (modifier === 'Default') {
+                return this.registry.findCodec(valueTypeId).tryDecode(hexToU8a(defaultValue));
+            }
+        }
+        else {
+            return this.registry.findCodec(valueTypeId).tryDecode($StorageData.tryEncode(raw));
+        }
+    }
+    #extractRequiredKeyInputs(keyInput, numberOfValue) {
+        if (numberOfValue === 0) {
+            return [];
+        }
+        else {
+            if (keyInput === undefined) {
+                throw new Error(`Invalid key inputs, required ${numberOfValue} input(s)`);
+            }
+            if (numberOfValue === 1) {
+                return [keyInput];
+            }
+            else {
+                if (!Array.isArray(keyInput)) {
+                    throw new Error(`Input should be an array with ${numberOfValue} value(s)`);
+                }
+                if (keyInput.length !== numberOfValue) {
+                    throw new Error(`Mismatch key inputs length, required an array of ${numberOfValue} value(s)`);
+                }
+                return keyInput.slice(0, numberOfValue);
+            }
+        }
+    }
+    #getPallet() {
+        const targetPallet = this.registry.metadata.pallets.find((p) => stringCamelCase(p.name) === stringCamelCase(this.palletName));
+        assert(targetPallet, new UnknownApiError(`Pallet not found: ${this.palletName}`));
+        return targetPallet;
+    }
+    #getStorageEntry() {
+        const targetEntry = this.pallet.storage?.entries?.find((entry) => stringCamelCase(entry.name) === stringCamelCase(this.storageItem));
+        assert(targetEntry, new UnknownApiError(`Storage item not found: ${this.storageItem}`));
+        return targetEntry;
+    }
+}

package/storage/index.d.ts

@@ -0,0 +1 @@
+export * from './QueryableStorage.js';

package/storage/index.js

@@ -0,0 +1 @@
+export * from './QueryableStorage.js';