dedot 0.0.1-alpha.22

package/cjs/extrinsic/extensions/known/CheckMortality.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckMortality = exports.MORTAL_PERIOD = exports.FALLBACK_PERIOD = exports.FALLBACK_MAX_HASH_COUNT = exports.MAX_FINALITY_LAG = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const utils_1 = require("@dedot/utils");
+const util_1 = require("@polkadot/util");
+exports.MAX_FINALITY_LAG = 5;
+exports.FALLBACK_MAX_HASH_COUNT = 250;
+exports.FALLBACK_PERIOD = 6 * 1000;
+exports.MORTAL_PERIOD = 5 * 60 * 1000;
+/**
+ * @description Check for transaction mortality.
+ */
+class CheckMortality extends SignedExtension_1.SignedExtension {
+    #signingHeader;
+    async init() {
+        this.#signingHeader = await this.#determineSigningHeader();
+        this.data = { period: this.#calculateMortalLength(), current: BigInt(this.#signingHeader.number) };
+        this.additionalSigned = (await this.api.rpc.chain.getBlockHash(this.#signingHeader.number));
+    }
+    // Ref: https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/api-derive/src/tx/signingInfo.ts#L34-L64
+    async #determineSigningHeader() {
+        const [header, finalizedHash] = await Promise.all([
+            this.api.rpc.chain.getHeader(),
+            this.api.rpc.chain.getFinalizedHead(),
+        ]);
+        (0, utils_1.assert)(header, 'Current header not found');
+        const [currentHeader, finalizedHeader] = await Promise.all([
+            Promise.resolve(header).then((header) => {
+                const { parentHash } = header;
+                if (parentHash.length === 0 || (0, utils_1.isZeroHash)(parentHash)) {
+                    return header;
+                }
+                else {
+                    return this.api.rpc.chain.getHeader(parentHash);
+                }
+            }),
+            this.api.rpc.chain.getHeader(finalizedHash),
+        ]);
+        (0, utils_1.assert)(currentHeader, 'Cannot determine current header');
+        if (!finalizedHeader || currentHeader.number - finalizedHeader.number > exports.MAX_FINALITY_LAG) {
+            return currentHeader;
+        }
+        return finalizedHeader;
+    }
+    // Ref: https://github.com/polkadot-js/api/blob/3bdf49b0428a62f16b3222b9a31bfefa43c1ca55/packages/api-derive/src/tx/signingInfo.ts#L83-L93
+    #calculateMortalLength() {
+        return (0, utils_1.min)(BigInt(this.#getConst('system', 'blockHashCount') || exports.FALLBACK_MAX_HASH_COUNT), BigInt(exports.MORTAL_PERIOD) /
+            BigInt(this.#getConst('babe', 'expectedBlockTime') ||
+                BigInt(this.#getConst('timestamp', 'minimumPeriod') || 0) * 2n ||
+                exports.FALLBACK_PERIOD) +
+            BigInt(exports.MAX_FINALITY_LAG));
+    }
+    #getConst(pallet, name) {
+        try {
+            return this.api.consts[pallet][name];
+        }
+        catch {
+            // ignore this on purpose
+        }
+        return undefined;
+    }
+    toPayload() {
+        return {
+            era: (0, util_1.u8aToHex)(this.dataCodec.tryEncode(this.data)),
+            blockHash: this.additionalSigned,
+            blockNumber: (0, util_1.numberToHex)(this.#signingHeader.number),
+        };
+    }
+}
+exports.CheckMortality = CheckMortality;

package/cjs/extrinsic/extensions/known/CheckNonZeroSender.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckNonZeroSender = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+/**
+ * @description Check to ensure that the sender is not the zero address
+ */
+class CheckNonZeroSender extends SignedExtension_1.SignedExtension {
+}
+exports.CheckNonZeroSender = CheckNonZeroSender;

package/cjs/extrinsic/extensions/known/CheckNonce.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckNonce = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const util_1 = require("@polkadot/util");
+const utils_1 = require("@dedot/utils");
+/**
+ * @description Nonce check and increment to give replay protection for transactions.
+ */
+class CheckNonce extends SignedExtension_1.SignedExtension {
+    async init() {
+        this.data = this.payloadOptions.nonce || (await this.#getNonce());
+    }
+    async #getNonce() {
+        const { signerAddress } = this.options || {};
+        (0, utils_1.assert)(signerAddress, 'Signer address not found');
+        try {
+            return (await this.api.query.system.account(signerAddress)).nonce;
+        }
+        catch { }
+        try {
+            return await this.api.call.accountNonceApi.accountNonce(signerAddress);
+        }
+        catch { }
+        // TODO fallback to api.rpc.system.accountNextIndex if needed
+        return 0;
+    }
+    toPayload() {
+        return {
+            nonce: (0, util_1.numberToHex)(this.data),
+        };
+    }
+}
+exports.CheckNonce = CheckNonce;

package/cjs/extrinsic/extensions/known/CheckSpecVersion.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckSpecVersion = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const util_1 = require("@polkadot/util");
+/**
+ * @description Ensure the runtime version registered in the transaction is the same as at present.
+ */
+class CheckSpecVersion extends SignedExtension_1.SignedExtension {
+    async init() {
+        this.additionalSigned = this.api.runtimeVersion.specVersion;
+    }
+    toPayload() {
+        return {
+            specVersion: (0, util_1.numberToHex)(this.additionalSigned),
+        };
+    }
+}
+exports.CheckSpecVersion = CheckSpecVersion;

package/cjs/extrinsic/extensions/known/CheckTxVersion.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckTxVersion = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+const util_1 = require("@polkadot/util");
+/**
+ * @description Ensure the transaction version registered in the transaction is the same as at present.
+ */
+class CheckTxVersion extends SignedExtension_1.SignedExtension {
+    async init() {
+        this.additionalSigned = this.api.runtimeVersion.transactionVersion;
+    }
+    toPayload() {
+        return {
+            transactionVersion: (0, util_1.numberToHex)(this.additionalSigned),
+        };
+    }
+}
+exports.CheckTxVersion = CheckTxVersion;

package/cjs/extrinsic/extensions/known/CheckWeight.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckWeight = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+/**
+ * @description Block resource (weight) limit check.
+ */
+class CheckWeight extends SignedExtension_1.SignedExtension {
+}
+exports.CheckWeight = CheckWeight;

package/cjs/extrinsic/extensions/known/PrevalidateAttests.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrevalidateAttests = void 0;
+const SignedExtension_1 = require("../SignedExtension");
+/**
+ * @description Validate `attest` calls prior to execution.
+ * Needed to avoid a DoS attack since they are otherwise free to place on chain.
+ */
+class PrevalidateAttests extends SignedExtension_1.SignedExtension {
+}
+exports.PrevalidateAttests = PrevalidateAttests;

package/cjs/extrinsic/extensions/known/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.knownSignedExtensions = void 0;
+const CheckNonZeroSender_1 = require("./CheckNonZeroSender");
+const CheckSpecVersion_1 = require("./CheckSpecVersion");
+const CheckTxVersion_1 = require("./CheckTxVersion");
+const CheckGenesis_1 = require("./CheckGenesis");
+const CheckMortality_1 = require("./CheckMortality");
+const CheckNonce_1 = require("./CheckNonce");
+const CheckWeight_1 = require("./CheckWeight");
+const ChargeTransactionPayment_1 = require("./ChargeTransactionPayment");
+const PrevalidateAttests_1 = require("./PrevalidateAttests");
+const ChargeAssetTxPayment_1 = require("./ChargeAssetTxPayment");
+exports.knownSignedExtensions = {
+    CheckNonZeroSender: CheckNonZeroSender_1.CheckNonZeroSender,
+    CheckSpecVersion: CheckSpecVersion_1.CheckSpecVersion,
+    CheckTxVersion: CheckTxVersion_1.CheckTxVersion,
+    CheckGenesis: CheckGenesis_1.CheckGenesis,
+    CheckMortality: CheckMortality_1.CheckMortality,
+    CheckNonce: CheckNonce_1.CheckNonce,
+    CheckWeight: CheckWeight_1.CheckWeight,
+    ChargeTransactionPayment: ChargeTransactionPayment_1.ChargeTransactionPayment,
+    PrevalidateAttests: PrevalidateAttests_1.PrevalidateAttests,
+    ChargeAssetTxPayment: ChargeAssetTxPayment_1.ChargeAssetTxPayment,
+};

package/cjs/extrinsic/index.js

@@ -0,0 +1,18 @@
+"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("./extensions"), exports);
+__exportStar(require("./SubmittableResult"), exports);

package/cjs/index.js

@@ -0,0 +1,25 @@
+"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 });
+exports.WsProvider = exports.ScProvider = exports.HttpProvider = exports.Dedot = void 0;
+const client_1 = require("./client");
+Object.defineProperty(exports, "Dedot", { enumerable: true, get: function () { return client_1.Dedot; } });
+__exportStar(require("./executor"), exports);
+__exportStar(require("./extrinsic"), exports);
+var rpc_provider_1 = require("@polkadot/rpc-provider");
+Object.defineProperty(exports, "HttpProvider", { enumerable: true, get: function () { return rpc_provider_1.HttpProvider; } });
+Object.defineProperty(exports, "ScProvider", { enumerable: true, get: function () { return rpc_provider_1.ScProvider; } });
+Object.defineProperty(exports, "WsProvider", { enumerable: true, get: function () { return rpc_provider_1.WsProvider; } });

package/cjs/package.json

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

package/cjs/packageInfo.js

@@ -0,0 +1,5 @@
+"use strict";
+// THIS FILE IS AUTO-GENERATED, DO NOT EDIT!
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageInfo = void 0;
+exports.packageInfo = { name: 'dedot', version: '0.0.1-alpha.21' };

package/cjs/proxychain.js

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

package/cjs/storage/QueryableStorage.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryableStorage = void 0;
+const utils_1 = require("@dedot/utils");
+const codecs_1 = require("@dedot/codecs");
+const util_1 = require("@polkadot/util");
+const util_crypto_1 = require("@polkadot/util-crypto");
+/**
+ * @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();
+    }
+    encodeKey(keyInput) {
+        const palletNameHash = (0, util_crypto_1.xxhashAsU8a)(this.pallet.name, 128);
+        const storageItemHash = (0, util_crypto_1.xxhashAsU8a)(this.storageEntry.name, 128);
+        const prefixHash = (0, util_1.u8aConcat)(palletNameHash, storageItemHash);
+        const { type } = this.storageEntry;
+        if (type.tag === 'Plain') {
+            return (0, util_1.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);
+                (0, utils_1.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 = utils_1.HASHERS[hashers[index]];
+                const $keyCodec = this.registry.findPortableCodec(keyId);
+                return hasher($keyCodec.tryEncode(input));
+            });
+            return (0, util_1.u8aToHex)((0, util_1.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((0, util_1.hexToU8a)(defaultValue));
+            }
+        }
+        else {
+            return this.registry.findPortableCodec(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, util_1.stringCamelCase)(p.name) === (0, util_1.stringCamelCase)(this.palletName));
+        (0, utils_1.assert)(targetPallet, `Pallet not found: ${this.palletName}`);
+        return targetPallet;
+    }
+    #getStorageEntry() {
+        const targetEntry = this.pallet.storage?.entries?.find((entry) => (0, util_1.stringCamelCase)(entry.name) === (0, util_1.stringCamelCase)(this.storageItem));
+        (0, utils_1.assert)(targetEntry, `Storage item not found: ${this.storageItem}`);
+        return targetEntry;
+    }
+}
+exports.QueryableStorage = QueryableStorage;

package/cjs/types.js

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

package/client/Dedot.d.ts

@@ -0,0 +1,181 @@
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+import type { SubstrateApi } from '@dedot/chaintypes';
+import { BlockHash, CodecRegistry, Metadata, MetadataLatest } from '@dedot/codecs';
+import { ChainProperties, GenericSubstrateApi } from '@dedot/types';
+import { ApiOptions, MetadataKey, NetworkEndpoint, NormalizedApiOptions } from '../types';
+export declare const KEEP_ALIVE_INTERVAL = 10000;
+export declare const CATCH_ALL_METADATA_KEY: MetadataKey;
+export declare const SUPPORTED_METADATA_VERSIONS: number[];
+/**
+ * @name Dedot
+ * @description Promised-based API Client for Polkadot & Substrate
+ *
+ * ### Initialize API instance and interact with substrate-based network
+ * ```typescript
+ * import { Dedot } from 'dedot';
+ * import { PolkadotApi } from '@dedot/chaintypes/polkadot';
+ *
+ * const run = async () => {
+ *   const api = await Dedot.new<PolkadotApi>('wss://rpc.polkadot.io');
+ *
+ *   // Call rpc `state_getMetadata` to fetch raw scale-encoded metadata and decode it.
+ *   const metadata = await api.rpc.state.getMetadata();
+ *   console.log('Metadata:', metadata);
+ *
+ *   // Query on-chain storage
+ *   const address = '14...';
+ *   const balance = await api.query.system.account(address);
+ *   console.log('Balance:', balance);
+ *
+ *
+ *   // Subscribe to on-chain storage changes
+ *   const unsub = await api.query.system.number((blockNumber) => {
+ *     console.log(`Current block number: ${blockNumber}`);
+ *   });
+ *
+ *   // Get pallet constants
+ *   const ss58Prefix = api.consts.system.ss58Prefix;
+ *   console.log('Polkadot ss58Prefix:', ss58Prefix)
+ *
+ *   // await unsub();
+ *   // await api.disconnect();
+ * }
+ *
+ * run().catch(console.error);
+ * ```
+ */
+export declare class Dedot<ChainApi extends GenericSubstrateApi = SubstrateApi> {
+    #private;
+    /**
+     * Use factory methods (`create`, `new`) to create `Dedot` instances.
+     *
+     * @param options
+     * @protected
+     */
+    protected constructor(options: ApiOptions | NetworkEndpoint);
+    /**
+     * Factory method to create a new Dedot instance
+     *
+     * @param options
+     */
+    static create<ChainApi extends GenericSubstrateApi = SubstrateApi>(options: ApiOptions | NetworkEndpoint): Promise<Dedot<ChainApi>>;
+    /**
+     * Alias for __Dedot.create__
+     * @param options
+     */
+    static new<ChainApi extends GenericSubstrateApi = SubstrateApi>(options: ApiOptions | NetworkEndpoint): Promise<Dedot<ChainApi>>;
+    /**
+     * Initialize APIs before usage
+     */
+    init(): Promise<void>;
+    /**
+     * @description Entry-point for executing RPCs to blockchain node.
+     *
+     * ```typescript
+     * // Subscribe to new heads
+     * api.rpc.chain.subscribeNewHeads((header) => {
+     *   console.log(header);
+     * });
+     *
+     * // Execute arbitrary rpc method: `module_rpc_name`
+     * const result = await api.rpc.module.rpc_name();
+     * ```
+     */
+    get rpc(): ChainApi['rpc'];
+    /**
+     * @description Entry-point for inspecting constants (parameter types) for all pallets (modules).
+     *
+     * ```typescript
+     * const ss58Prefix = api.consts.system.ss58Prefix;
+     * console.log('ss58Prefix:', ss58Prefix)
+     * ```
+     */
+    get consts(): ChainApi['consts'];
+    /**
+     * @description Entry-point for executing query to on-chain storage.
+     *
+     * ```typescript
+     * const balance = await api.query.system.account(<address>);
+     * console.log('Balance:', balance);
+     * ```
+     */
+    get query(): ChainApi['query'];
+    queryAt(blockHash: BlockHash): ChainApi['query'];
+    /**
+     * @description Entry-point for inspecting errors from metadata
+     */
+    get errors(): ChainApi['errors'];
+    /**
+     * @description Entry-point for inspecting events from metadata
+     */
+    get events(): ChainApi['events'];
+    get call(): ChainApi['call'];
+    callAt(blockHash: BlockHash): ChainApi['call'];
+    get tx(): ChainApi['tx'];
+    /**
+     * @description Current provider for api connection
+     */
+    get provider(): ProviderInterface;
+    /**
+     * @description Codec registry
+     */
+    get registry(): CodecRegistry;
+    /**
+     * @description Check if metadata is present
+     */
+    get hasMetadata(): boolean;
+    get metadata(): Metadata;
+    get metadataLatest(): MetadataLatest;
+    /**
+     * Setup metadata for
+     * @param metadata
+     */
+    setMetadata(metadata: Metadata): void;
+    /**
+     * @description Disconnect to blockchain node
+     */
+    disconnect(): Promise<void>;
+    /**
+     * @description Clear local cache
+     */
+    clearCache(): Promise<void>;
+    /**
+     * @description Check if current provider can make subscription request (e.: via WebSocket)
+     */
+    get hasSubscriptions(): boolean;
+    /**
+     * @description Check if it's connected to the blockchain node
+     */
+    get isConnected(): boolean;
+    /**
+     * @description Check if the api instance is using a catch-all metadata
+     */
+    get hasCatchAllMetadata(): boolean;
+    get currentMetadataKey(): string;
+    /**
+     * @description Genesis hash of connected blockchain node
+     */
+    get genesisHash(): `0x${string}` | undefined;
+    /**
+     * @description Runtime version of connected blockchain node
+     */
+    get runtimeVersion(): {
+        specName: string;
+        implName: string;
+        authoringVersion: number;
+        specVersion: number;
+        implVersion: number;
+        apis: (readonly [`0x${string}`, number])[];
+        transactionVersion: number;
+        stateVersion: number;
+    } | undefined;
+    /**
+     * @description Chain properties of connected blockchain node
+     */
+    get chainProperties(): ChainProperties | undefined;
+    /**
+     * @description Runtime chain name of connected blockchain node
+     */
+    get runtimeChain(): string | undefined;
+    get options(): NormalizedApiOptions;
+}