@dedot/api 0.0.1-alpha.32

package/cjs/json-rpc/group/ChainSpec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainSpec = void 0;
+const JsonRpcGroup_js_1 = require("./JsonRpcGroup.js");
+class ChainSpec extends JsonRpcGroup_js_1.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');
+    }
+}
+exports.ChainSpec = ChainSpec;

package/cjs/json-rpc/group/JsonRpcGroup.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcGroup = void 0;
+const utils_1 = require("@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
+ */
+class JsonRpcGroup extends utils_1.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];
+    }
+}
+exports.JsonRpcGroup = JsonRpcGroup;

package/cjs/json-rpc/group/Transaction.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const utils_1 = require("@dedot/utils");
+const JsonRpcGroup_js_1 = require("./JsonRpcGroup.js");
+class Transaction extends JsonRpcGroup_js_1.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);
+        (0, utils_1.assert)(operationId, 'Maximum number of broadcasted transactions has been reached');
+        return operationId;
+    }
+    stop(operationId) {
+        return this.send('stop', operationId);
+    }
+}
+exports.Transaction = Transaction;

package/cjs/json-rpc/group/TransactionWatch.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionWatch = void 0;
+const utils_1 = require("@dedot/utils");
+const JsonRpcGroup_js_1 = require("./JsonRpcGroup.js");
+class TransactionWatch extends JsonRpcGroup_js_1.JsonRpcGroup {
+    constructor(client, options) {
+        super(client, { prefix: 'transactionWatch', supportedVersions: ['unstable'], ...options });
+    }
+    broadcastTx(tx) {
+        return this.submitAndWatch(tx, utils_1.noop);
+    }
+    async submitAndWatch(tx, callback) {
+        return this.send('submitAndWatch', tx, callback);
+    }
+}
+exports.TransactionWatch = TransactionWatch;

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

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./JsonRpcGroup.js"), exports);
+__exportStar(require("./ChainSpec.js"), exports);
+__exportStar(require("./Transaction.js"), exports);
+__exportStar(require("./TransactionWatch.js"), exports);
+__exportStar(require("./ChainHead/index.js"), exports);

package/cjs/json-rpc/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./subscriptionsInfo.js"), exports);
+__exportStar(require("./scaledResponses.js"), exports);
+__exportStar(require("./JsonRpcClient.js"), exports);
+__exportStar(require("./group/index.js"), exports);

package/cjs/json-rpc/scaledResponses.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaledResponses = void 0;
+const codecs_1 = require("@dedot/codecs");
+exports.scaledResponses = {
+    system_dryRun: codecs_1.$ApplyExtrinsicResult,
+    state_getMetadata: codecs_1.$Metadata,
+    chain_getHeader: codecs_1.$Header,
+    chain_getBlock: codecs_1.$SignedBlock,
+    chain_subscribeAllHeads: codecs_1.$Header,
+    chain_subscribeNewHeads: codecs_1.$Header,
+    chain_subscribeFinalizedHeads: codecs_1.$Header,
+    author_submitAndWatchExtrinsic: codecs_1.$TransactionStatus,
+    beefy_subscribeJustifications: codecs_1.$VersionedFinalityProof,
+};

package/cjs/json-rpc/subscriptionsInfo.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subscriptionsInfo = void 0;
+exports.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/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/cjs/proxychain.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.newProxyChain = void 0;
+/**
+ * Create a chain of proxy objects
+ *
+ * @param carrier
+ * @param currentLevel
+ * @param maxLevel
+ */
+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 (0, exports.newProxyChain)(target, currentLevel + 1, maxLevel);
+        },
+    });
+};
+exports.newProxyChain = newProxyChain;

package/cjs/storage/QueryableStorage.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryableStorage = void 0;
+const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
+const utils_2 = require("@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
+ */
+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 (0, utils_2.u8aToHex)(this.prefixKeyAsU8a);
+    }
+    get prefixKeyAsU8a() {
+        const palletNameHash = (0, utils_2.xxhashAsU8a)(this.pallet.name, 128);
+        const storageItemHash = (0, utils_2.xxhashAsU8a)(this.storageEntry.name, 128);
+        return (0, utils_2.concatU8a)(palletNameHash, storageItemHash);
+    }
+    #getStorageMapInfo(type) {
+        (0, utils_1.assert)(type.tag === 'Map');
+        const { hashers, keyTypeId } = type.value;
+        let keyTypeIds = [keyTypeId];
+        if (hashers.length > 1) {
+            const { type } = this.registry.findType(keyTypeId);
+            (0, utils_1.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 = utils_1.HASHERS[hashers[index]];
+                const $keyCodec = this.registry.findCodec(keyId);
+                return hasher($keyCodec.tryEncode(input));
+            });
+            return (0, utils_2.u8aToHex)((0, utils_2.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 = (0, utils_2.hexToU8a)((0, utils_1.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((0, utils_2.hexToU8a)(defaultValue));
+            }
+        }
+        else {
+            return this.registry.findCodec(valueTypeId).tryDecode(codecs_1.$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) => (0, utils_2.stringCamelCase)(p.name) === (0, utils_2.stringCamelCase)(this.palletName));
+        (0, utils_1.assert)(targetPallet, new utils_1.UnknownApiError(`Pallet not found: ${this.palletName}`));
+        return targetPallet;
+    }
+    #getStorageEntry() {
+        const targetEntry = this.pallet.storage?.entries?.find((entry) => (0, utils_2.stringCamelCase)(entry.name) === (0, utils_2.stringCamelCase)(this.storageItem));
+        (0, utils_1.assert)(targetEntry, new utils_1.UnknownApiError(`Storage item not found: ${this.storageItem}`));
+        return targetEntry;
+    }
+}
+exports.QueryableStorage = QueryableStorage;

package/cjs/storage/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./QueryableStorage.js"), exports);

package/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/client/BaseSubstrateClient.d.ts

@@ -0,0 +1,65 @@
+import { BlockHash, Hash, Metadata, PortableRegistry, RuntimeVersion } from '@dedot/codecs';
+import type { JsonRpcProvider } from '@dedot/providers';
+import { type IStorage } from '@dedot/storage';
+import { GenericSubstrateApi, RpcVersion, VersionedGenericSubstrateApi } from '@dedot/types';
+import type { SubstrateApi } from '../chaintypes/index.js';
+import { JsonRpcClient } from '../json-rpc/index.js';
+import type { ApiEvent, ApiOptions, ISubstrateClient, ISubstrateClientAt, JsonRpcClientOptions, MetadataKey, SubstrateRuntimeVersion } from '../types.js';
+export declare function ensurePresence<T>(value: T): NonNullable<T>;
+/**
+ * @name BaseSubstrateClient
+ * @description Base & shared abstraction for Substrate API Clients
+ */
+export declare abstract class BaseSubstrateClient<ChainApi extends VersionedGenericSubstrateApi = SubstrateApi> extends JsonRpcClient<ChainApi[RpcVersion], ApiEvent> implements ISubstrateClient<ChainApi[RpcVersion]> {
+    rpcVersion: RpcVersion;
+    protected _options: ApiOptions;
+    protected _registry?: PortableRegistry;
+    protected _metadata?: Metadata;
+    protected _genesisHash?: Hash;
+    protected _runtimeVersion?: SubstrateRuntimeVersion;
+    protected _localCache?: IStorage;
+    protected constructor(rpcVersion: RpcVersion, options: JsonRpcClientOptions | JsonRpcProvider);
+    protected normalizeOptions(options: ApiOptions | JsonRpcProvider): ApiOptions;
+    protected initializeLocalCache(): Promise<void>;
+    protected setupMetadata(preloadMetadata: Metadata | undefined): Promise<void>;
+    protected setMetadata(metadata: Metadata): void;
+    protected getMetadataKey(runtime?: SubstrateRuntimeVersion): MetadataKey;
+    get currentMetadataKey(): string;
+    protected shouldPreloadMetadata(): Promise<boolean>;
+    protected getMetadataFromOptions(runtime?: SubstrateRuntimeVersion): Metadata | undefined;
+    protected fetchMetadata(hash?: BlockHash, runtime?: SubstrateRuntimeVersion): Promise<Metadata>;
+    protected cleanUp(): void;
+    /**
+     * @description Clear local cache
+     */
+    clearCache(): Promise<void>;
+    protected doConnect(): Promise<this>;
+    protected onConnected: () => Promise<void>;
+    protected onDisconnected: () => Promise<void>;
+    protected initialize(): Promise<void>;
+    protected doInitialize(): Promise<void>;
+    protected beforeDisconnect(): Promise<void>;
+    protected afterDisconnect(): Promise<void>;
+    protected toSubstrateRuntimeVersion(runtimeVersion: RuntimeVersion): SubstrateRuntimeVersion;
+    /**
+     * @description Connect to blockchain node
+     */
+    connect(): Promise<this>;
+    /**
+     * @description Disconnect to blockchain node
+     */
+    disconnect(): Promise<void>;
+    get options(): ApiOptions;
+    get metadata(): Metadata;
+    get registry(): PortableRegistry;
+    get genesisHash(): Hash;
+    get runtimeVersion(): SubstrateRuntimeVersion;
+    get consts(): ChainApi[RpcVersion]['consts'];
+    get errors(): ChainApi[RpcVersion]['errors'];
+    get events(): ChainApi[RpcVersion]['events'];
+    get query(): ChainApi[RpcVersion]['query'];
+    get call(): ChainApi[RpcVersion]['call'];
+    protected callAt(hash?: BlockHash): ChainApi[RpcVersion]['call'];
+    get tx(): ChainApi[RpcVersion]['tx'];
+    at<ChainApiAt extends GenericSubstrateApi = ChainApi[RpcVersion]>(hash: BlockHash): Promise<ISubstrateClientAt<ChainApiAt>>;
+}