dedot 0.0.1-alpha.22

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "dedot",
+  "version": "0.0.1-alpha.22",
+  "description": "A fast & lightweight 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",
+  "dependencies": {
+    "@dedot/chaintypes": "0.0.1-alpha.22",
+    "@dedot/codecs": "0.0.1-alpha.22",
+    "@dedot/shape": "0.0.1-alpha.22",
+    "@dedot/specs": "0.0.1-alpha.22",
+    "@dedot/utils": "0.0.1-alpha.22",
+    "@polkadot/rpc-provider": "^10.11.2",
+    "@polkadot/util": "^12.6.2",
+    "@polkadot/util-crypto": "^12.6.2",
+    "localforage": "^1.10.0"
+  },
+  "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"
+  },
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@polkadot/keyring": "^12.6.2",
+    "@polkadot/types": "^10.11.2"
+  },
+  "gitHead": "535f3ade0fa48d6d8aeabb1a1c9ed26b82e9e836",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "default": "./cjs/index.js"
+      }
+    }
+  }
+}

package/packageInfo.d.ts

@@ -0,0 +1,4 @@
+export declare const packageInfo: {
+    name: string;
+    version: string;
+};

package/packageInfo.js

@@ -0,0 +1,3 @@
+// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
+
+export const packageInfo = { name: 'dedot', version: '0.0.1-alpha.22' };

package/proxychain.d.ts

@@ -0,0 +1,7 @@
+import { GenericSubstrateApi } from '@dedot/types';
+import { Executor } from './executor';
+export interface Carrier<ChainApi extends GenericSubstrateApi> {
+    executor: Executor<ChainApi>;
+    chain?: string[];
+}
+export declare const newProxyChain: <ChainApi extends GenericSubstrateApi>(carrier: Carrier<ChainApi>, currentLevel?: number, maxLevel?: number) => unknown;

package/proxychain.js

@@ -0,0 +1,16 @@
+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);
+        },
+    });
+};

package/storage/QueryableStorage.d.ts

@@ -0,0 +1,16 @@
+import { CodecRegistry, PalletDefLatest, StorageDataLike, StorageEntryLatest, StorageKey } from '@dedot/codecs';
+/**
+ * @name QueryableStorage
+ * @description A helper to encode key & decode value for a storage entry
+ */
+export declare class QueryableStorage {
+    #private;
+    readonly registry: CodecRegistry;
+    readonly palletName: string;
+    readonly storageItem: string;
+    readonly pallet: PalletDefLatest;
+    readonly storageEntry: StorageEntryLatest;
+    constructor(registry: CodecRegistry, palletName: string, storageItem: string);
+    encodeKey(keyInput?: any): StorageKey;
+    decodeValue(raw?: StorageDataLike | null): any;
+}

package/storage/QueryableStorage.js

@@ -0,0 +1,95 @@
+import { assert, HASHERS } from '@dedot/utils';
+import { $StorageData, } from '@dedot/codecs';
+import { hexToU8a, stringCamelCase, u8aConcat, u8aToHex } from '@polkadot/util';
+import { xxhashAsU8a } from '@polkadot/util-crypto';
+/**
+ * @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();
+    }
+    encodeKey(keyInput) {
+        const palletNameHash = xxhashAsU8a(this.pallet.name, 128);
+        const storageItemHash = xxhashAsU8a(this.storageEntry.name, 128);
+        const prefixHash = u8aConcat(palletNameHash, storageItemHash);
+        const { type } = this.storageEntry;
+        if (type.tag === 'Plain') {
+            return u8aToHex(prefixHash);
+        }
+        else if (type.tag === 'Map') {
+            const { hashers, keyTypeId } = type.value;
+            const extractedInputs = this.#extractRequiredKeyInputs(keyInput, hashers.length);
+            let keyTypeIds = [keyTypeId];
+            if (hashers.length > 1) {
+                const { type } = this.registry.findPortableType(keyTypeId);
+                assert(type.tag === 'Tuple', 'Key type should be a tuple!');
+                keyTypeIds = type.value.fields;
+            }
+            const keyParts = keyTypeIds.map((keyId, index) => {
+                const input = extractedInputs[index];
+                const hasher = HASHERS[hashers[index]];
+                const $keyCodec = this.registry.findPortableCodec(keyId);
+                return hasher($keyCodec.tryEncode(input));
+            });
+            return u8aToHex(u8aConcat(prefixHash, ...keyParts));
+        }
+        throw Error(`Invalid storage entry type: ${type}`);
+    }
+    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.findPortableCodec(valueTypeId).tryDecode(hexToU8a(defaultValue));
+            }
+        }
+        else {
+            return this.registry.findPortableCodec(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, `Pallet not found: ${this.palletName}`);
+        return targetPallet;
+    }
+    #getStorageEntry() {
+        const targetEntry = this.pallet.storage?.entries?.find((entry) => stringCamelCase(entry.name) === stringCamelCase(this.storageItem));
+        assert(targetEntry, `Storage item not found: ${this.storageItem}`);
+        return targetEntry;
+    }
+}

package/types.d.ts

@@ -0,0 +1,44 @@
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import { HexString } from '@dedot/utils';
+import { AnySignedExtension } from './extrinsic';
+export type NetworkEndpoint = string;
+export type MetadataKey = `RAW_META/${string}`;
+export interface ApiOptions {
+    provider?: ProviderInterface;
+    /**
+     * @description A `ProviderInterface` will be created based on the supplied endpoint.
+     * If both `provider` and `endpoint` is provided, the `provider` will be used for connection.
+     *
+     * A valid endpoint should start with `wss://`, `ws://`, `https://` or `http://`
+     */
+    endpoint?: NetworkEndpoint;
+    /**
+     * @description Cache metadata in local storage for next time usage
+     * For now this only supports browser environments
+     *
+     * @default: false
+     */
+    cacheMetadata?: boolean;
+    /**
+     * @description Metadata is usually downloaded from chain via RPC upon API initialization,
+     * We can supply the metadata directly via this option to skip the download metadata step.
+     *
+     * Metadata Key format: `RAW_META/{genesisHash}/{runtimeSpecVersion}`
+     *
+     * If the `genesisHash` & `runtimeSpecVersion` of the supplied metadata key match with connected chain,
+     * then use the provided metadata, else we fetch it anew from chain.
+     *
+     * Catch-all Metadata Key (`RAW_META/ALL`) will be used
+     * regardless of the `genesisHash` or `runtimeSpecVersion` of connected chain.
+     *
+     * If we supplied a raw-hex metadata to this option, it's a catch-all metadata.
+     */
+    metadata?: HexString | Record<MetadataKey, HexString>;
+    /**
+     * @description User-defined chain-specific signed extensions
+     */
+    signedExtensions?: Record<string, AnySignedExtension>;
+}
+export interface NormalizedApiOptions extends ApiOptions {
+    metadata?: Record<string, HexString>;
+}

package/types.js

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