@dedot/api 0.7.1 → 0.8.0

package/cjs/executor/StorageQueryExecutor.js

@@ -77,17 +77,25 @@ class StorageQueryExecutor extends Executor_js_1.Executor {
         return queryFn;
     }
     exposeStorageMapMethods(entry) {
-        const rawKeys = async (pagination) => {
+        const rawKeys = async (partialInput, pagination) => {
             const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
             const startKey = pagination?.startKey || entry.prefixKey;
-            return await this.client.rpc.state_getKeysPaged(entry.prefixKey, pageSize, startKey, this.atBlockHash);
+            return await this.client.rpc.state_getKeysPaged(entry.encodeKey(partialInput, true), pageSize, startKey, this.atBlockHash);
         };
-        const pagedKeys = async (pagination) => {
-            const storageKeys = await rawKeys({ pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
+        const extractArgs = (args) => {
+            const inArgs = args.slice();
+            const lastArg = args.at(-1);
+            const pagination = (0, utils_1.isObject)(lastArg) && ('pageSize' in lastArg || 'startKey' in lastArg) ? inArgs.pop() : undefined;
+            return [inArgs, pagination];
+        };
+        const pagedKeys = async (...args) => {
+            const [inArgs, pagination] = extractArgs(args);
+            const storageKeys = await rawKeys(inArgs, { pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
             return storageKeys.map((key) => entry.decodeKey(key));
         };
-        const pagedEntries = async (pagination) => {
-            const storageKeys = await rawKeys({ pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
+        const pagedEntries = async (...args) => {
+            const [inArgs, pagination] = extractArgs(args);
+            const storageKeys = await rawKeys(inArgs, { pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
             const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
             return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(storageMap[key])]);
         };

package/cjs/executor/v2/StorageQueryExecutorV2.js

@@ -18,8 +18,12 @@ class StorageQueryExecutorV2 extends StorageQueryExecutor_js_1.StorageQueryExecu
         // so for now we're trying to pull all entries from storage
         // this might take a while for large storage
         // TODO improve this, fallback to use `archive`-prefixed if available?
-        const entries = async () => {
-            const results = await this.chainHead.storage([{ type: 'descendantsValues', key: entry.prefixKey }]);
+        const entries = async (...args) => {
+            const withArgs = !!args && args.length > 0;
+            const key = withArgs ? entry.encodeKey(args, true) : entry.prefixKey;
+            const results = await this.chainHead.storage([
+                { type: 'descendantsValues', key },
+            ]);
             return results.map(({ key, value }) => [
                 entry.decodeKey(key),
                 entry.decodeValue(value),

package/cjs/storage/QueryableStorage.js

@@ -54,17 +54,18 @@ class QueryableStorage {
      * Encode plain key input to raw/bytes storage key
      *
      * @param keyInput
+     * @param allowPartialKeys - allow partial keys, default is false
      */
-    encodeKey(keyInput) {
+    encodeKey(keyInput, allowPartialKeys = false) {
         const { storageType } = this.storageEntry;
         if (storageType.type === 'Plain') {
             return this.prefixKey;
         }
         else if (storageType.type === 'Map') {
             const { hashers, keyTypeIds } = this.#getStorageMapInfo(storageType);
-            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length);
-            const keyParts = keyTypeIds.map((keyId, index) => {
-                const input = extractedInputs[index];
+            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length, allowPartialKeys);
+            const keyParts = extractedInputs.map((input, index) => {
+                const keyId = keyTypeIds[index];
                 const hasher = utils_1.HASHERS[hashers[index]];
                 const $keyCodec = this.registry.findCodec(keyId);
                 return hasher($keyCodec.tryEncode(input));
@@ -125,7 +126,7 @@ class QueryableStorage {
             return this.registry.findCodec(valueTypeId).tryDecode(codecs_1.$StorageData.tryEncode(raw));
         }
     }
-    #extractRequiredKeyInputs(keyInput, numberOfValue) {
+    #extractRequiredKeyInputs(keyInput, numberOfValue, allowPartialKeys = false) {
         if (numberOfValue === 0) {
             return [];
         }
@@ -134,16 +135,25 @@ class QueryableStorage {
                 throw new Error(`Invalid key inputs, required ${numberOfValue} input(s)`);
             }
             if (numberOfValue === 1) {
-                return [keyInput];
+                return allowPartialKeys && Array.isArray(keyInput) ? keyInput : [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)`);
+                if (allowPartialKeys) {
+                    if (keyInput.length >= numberOfValue) {
+                        throw new Error(`Invalid key inputs, partial key inputs should be less than the required key inputs, (max: ${numberOfValue - 1})`);
+                    }
+                    // TODO we need to make sure only filter out values in the last positions
+                    return keyInput.slice(0, numberOfValue).filter((one) => one !== undefined && one !== null);
+                }
+                else {
+                    if (keyInput.length !== numberOfValue) {
+                        throw new Error(`Mismatch key inputs length, required an array of ${numberOfValue} value(s)`);
+                    }
+                    return keyInput.slice(0, numberOfValue);
                 }
-                return keyInput.slice(0, numberOfValue);
             }
         }
     }

package/executor/StorageQueryExecutor.js

@@ -1,4 +1,4 @@
-import { assert, isFunction } from '@dedot/utils';
+import { assert, isFunction, isObject } from '@dedot/utils';
 import { QueryableStorage } from '../storage/QueryableStorage.js';
 import { Executor } from './Executor.js';
 const DEFAULT_KEYS_PAGE_SIZE = 1000;
@@ -74,17 +74,25 @@ export class StorageQueryExecutor extends Executor {
         return queryFn;
     }
     exposeStorageMapMethods(entry) {
-        const rawKeys = async (pagination) => {
+        const rawKeys = async (partialInput, pagination) => {
             const pageSize = pagination?.pageSize || DEFAULT_KEYS_PAGE_SIZE;
             const startKey = pagination?.startKey || entry.prefixKey;
-            return await this.client.rpc.state_getKeysPaged(entry.prefixKey, pageSize, startKey, this.atBlockHash);
+            return await this.client.rpc.state_getKeysPaged(entry.encodeKey(partialInput, true), pageSize, startKey, this.atBlockHash);
         };
-        const pagedKeys = async (pagination) => {
-            const storageKeys = await rawKeys({ pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
+        const extractArgs = (args) => {
+            const inArgs = args.slice();
+            const lastArg = args.at(-1);
+            const pagination = isObject(lastArg) && ('pageSize' in lastArg || 'startKey' in lastArg) ? inArgs.pop() : undefined;
+            return [inArgs, pagination];
+        };
+        const pagedKeys = async (...args) => {
+            const [inArgs, pagination] = extractArgs(args);
+            const storageKeys = await rawKeys(inArgs, { pageSize: DEFAULT_KEYS_PAGE_SIZE, ...pagination });
             return storageKeys.map((key) => entry.decodeKey(key));
         };
-        const pagedEntries = async (pagination) => {
-            const storageKeys = await rawKeys({ pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
+        const pagedEntries = async (...args) => {
+            const [inArgs, pagination] = extractArgs(args);
+            const storageKeys = await rawKeys(inArgs, { pageSize: DEFAULT_ENTRIES_PAGE_SIZE, ...pagination });
             const storageMap = await this.queryStorage(storageKeys, this.atBlockHash);
             return storageKeys.map((key) => [entry.decodeKey(key), entry.decodeValue(storageMap[key])]);
         };

package/executor/v2/StorageQueryExecutorV2.js

@@ -15,8 +15,12 @@ export class StorageQueryExecutorV2 extends StorageQueryExecutor {
         // so for now we're trying to pull all entries from storage
         // this might take a while for large storage
         // TODO improve this, fallback to use `archive`-prefixed if available?
-        const entries = async () => {
-            const results = await this.chainHead.storage([{ type: 'descendantsValues', key: entry.prefixKey }]);
+        const entries = async (...args) => {
+            const withArgs = !!args && args.length > 0;
+            const key = withArgs ? entry.encodeKey(args, true) : entry.prefixKey;
+            const results = await this.chainHead.storage([
+                { type: 'descendantsValues', key },
+            ]);
             return results.map(({ key, value }) => [
                 entry.decodeKey(key),
                 entry.decodeValue(value),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dedot/api",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "A delightful JavaScript/TypeScript client for Polkadot & Substrate",
   "author": "Thang X. Vu <thang@coongcrafts.io>",
   "homepage": "https://github.com/dedotdev/dedot/tree/main/packages/api",
@@ -13,13 +13,13 @@
   "type": "module",
   "sideEffects": false,
   "dependencies": {
-    "@dedot/codecs": "0.7.1",
-    "@dedot/providers": "0.7.1",
-    "@dedot/runtime-specs": "0.7.1",
-    "@dedot/shape": "0.7.1",
-    "@dedot/storage": "0.7.1",
-    "@dedot/types": "0.7.1",
-    "@dedot/utils": "0.7.1"
+    "@dedot/codecs": "0.8.0",
+    "@dedot/providers": "0.8.0",
+    "@dedot/runtime-specs": "0.8.0",
+    "@dedot/shape": "0.8.0",
+    "@dedot/storage": "0.8.0",
+    "@dedot/types": "0.8.0",
+    "@dedot/utils": "0.8.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json && tsc --project tsconfig.build.cjs.json",
@@ -48,7 +48,7 @@
     "node": ">=18"
   },
   "license": "Apache-2.0",
-  "gitHead": "5743229117be17b74d16c35a2862da4c36a24045",
+  "gitHead": "95644163050c58b8d18bebf780734b308bb7a4b3",
   "module": "./index.js",
   "types": "./index.d.ts"
 }

package/storage/QueryableStorage.d.ts

@@ -17,8 +17,9 @@ export declare class QueryableStorage {
      * Encode plain key input to raw/bytes storage key
      *
      * @param keyInput
+     * @param allowPartialKeys - allow partial keys, default is false
      */
-    encodeKey(keyInput?: any): StorageKey;
+    encodeKey(keyInput?: any, allowPartialKeys?: boolean): StorageKey;
     /**
      * Decode storage key to plain key input
      * Only storage keys that hashed by `twox64Concat`, `blake2_128Concat`, or `identity` can be decoded

package/storage/QueryableStorage.js

@@ -51,17 +51,18 @@ export class QueryableStorage {
      * Encode plain key input to raw/bytes storage key
      *
      * @param keyInput
+     * @param allowPartialKeys - allow partial keys, default is false
      */
-    encodeKey(keyInput) {
+    encodeKey(keyInput, allowPartialKeys = false) {
         const { storageType } = this.storageEntry;
         if (storageType.type === 'Plain') {
             return this.prefixKey;
         }
         else if (storageType.type === 'Map') {
             const { hashers, keyTypeIds } = this.#getStorageMapInfo(storageType);
-            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length);
-            const keyParts = keyTypeIds.map((keyId, index) => {
-                const input = extractedInputs[index];
+            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length, allowPartialKeys);
+            const keyParts = extractedInputs.map((input, index) => {
+                const keyId = keyTypeIds[index];
                 const hasher = HASHERS[hashers[index]];
                 const $keyCodec = this.registry.findCodec(keyId);
                 return hasher($keyCodec.tryEncode(input));
@@ -122,7 +123,7 @@ export class QueryableStorage {
             return this.registry.findCodec(valueTypeId).tryDecode($StorageData.tryEncode(raw));
         }
     }
-    #extractRequiredKeyInputs(keyInput, numberOfValue) {
+    #extractRequiredKeyInputs(keyInput, numberOfValue, allowPartialKeys = false) {
         if (numberOfValue === 0) {
             return [];
         }
@@ -131,16 +132,25 @@ export class QueryableStorage {
                 throw new Error(`Invalid key inputs, required ${numberOfValue} input(s)`);
             }
             if (numberOfValue === 1) {
-                return [keyInput];
+                return allowPartialKeys && Array.isArray(keyInput) ? keyInput : [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)`);
+                if (allowPartialKeys) {
+                    if (keyInput.length >= numberOfValue) {
+                        throw new Error(`Invalid key inputs, partial key inputs should be less than the required key inputs, (max: ${numberOfValue - 1})`);
+                    }
+                    // TODO we need to make sure only filter out values in the last positions
+                    return keyInput.slice(0, numberOfValue).filter((one) => one !== undefined && one !== null);
+                }
+                else {
+                    if (keyInput.length !== numberOfValue) {
+                        throw new Error(`Mismatch key inputs length, required an array of ${numberOfValue} value(s)`);
+                    }
+                    return keyInput.slice(0, numberOfValue);
                 }
-                return keyInput.slice(0, numberOfValue);
             }
         }
     }