@dedot/api 0.0.1-alpha.32

package/cjs/extrinsic/submittable/BaseSubmittableExtrinsic.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSubmittableExtrinsic = void 0;
+const codecs_1 = require("@dedot/codecs");
+const utils_1 = require("@dedot/utils");
+const index_js_1 = require("../extensions/index.js");
+const fakeSigner_js_1 = require("./fakeSigner.js");
+const utils_js_1 = require("./utils.js");
+class BaseSubmittableExtrinsic extends codecs_1.Extrinsic {
+    api;
+    constructor(api, call) {
+        super(api.registry, call);
+        this.api = api;
+    }
+    async paymentInfo(account, options) {
+        await this.sign(account, { ...options, signer: fakeSigner_js_1.fakeSigner });
+        const txU8a = this.toU8a();
+        const api = this.api;
+        return api.call.transactionPaymentApi.queryInfo(txU8a, txU8a.length);
+    }
+    async sign(fromAccount, options) {
+        const address = (0, utils_js_1.isKeyringPair)(fromAccount) ? fromAccount.address : fromAccount.toString();
+        const extra = new index_js_1.ExtraSignedExtension(this.api, {
+            signerAddress: address,
+            payloadOptions: options,
+        });
+        await extra.init();
+        const { signer } = options || {};
+        let signature;
+        if ((0, utils_js_1.isKeyringPair)(fromAccount)) {
+            signature = (0, utils_1.u8aToHex)((0, utils_js_1.signRaw)(fromAccount, extra.toRawPayload(this.callHex).data));
+        }
+        else if (signer?.signPayload) {
+            const result = await signer.signPayload(extra.toPayload(this.callHex));
+            signature = result.signature;
+        }
+        else {
+            throw new Error('Signer not found. Cannot sign the extrinsic!');
+        }
+        const { signatureTypeId } = this.registry.metadata.extrinsic;
+        const $Signature = this.registry.findCodec(signatureTypeId);
+        this.attachSignature({
+            address: address,
+            signature: $Signature.tryDecode(signature),
+            extra: extra.data,
+        });
+        return this;
+    }
+    async signAndSend(fromAccount, partialOptions, maybeCallback) {
+        const [options, callback] = this.#normalizeOptions(partialOptions, maybeCallback);
+        await this.sign(fromAccount, options);
+        return this.send(callback);
+    }
+    #normalizeOptions(partialOptions, callback) {
+        if ((0, utils_1.isFunction)(partialOptions)) {
+            return [{}, partialOptions];
+        }
+        else {
+            return [Object.assign({}, partialOptions), callback];
+        }
+    }
+    send(callback) {
+        throw new Error('Unimplemented!');
+    }
+    async getSystemEventsAt(hash) {
+        const atApi = (await this.api.at(hash));
+        return await atApi.query.system.events();
+    }
+}
+exports.BaseSubmittableExtrinsic = BaseSubmittableExtrinsic;

package/cjs/extrinsic/submittable/SubmittableExtrinsic.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmittableExtrinsic = void 0;
+const utils_1 = require("@dedot/utils");
+const BaseSubmittableExtrinsic_js_1 = require("./BaseSubmittableExtrinsic.js");
+const SubmittableResult_js_1 = require("./SubmittableResult.js");
+/**
+ * @name SubmittableExtrinsic
+ * @description A wrapper around an Extrinsic that exposes methods to sign, send, and other utility around Extrinsic.
+ */
+class SubmittableExtrinsic extends BaseSubmittableExtrinsic_js_1.BaseSubmittableExtrinsic {
+    async dryRun(account, optionsOrHash) {
+        const dryRunFn = this.api.rpc.system_dryRun;
+        if ((0, utils_1.isHex)(optionsOrHash)) {
+            return dryRunFn(this.toHex(), optionsOrHash);
+        }
+        await this.sign(account, optionsOrHash);
+        return dryRunFn(this.toHex());
+    }
+    async send(callback) {
+        const isSubscription = !!callback;
+        const txHex = this.toHex();
+        const txHash = this.hash;
+        if (isSubscription) {
+            return this.api.rpc.author_submitAndWatchExtrinsic(txHex, async (status) => {
+                if (status.tag === 'InBlock' || status.tag === 'Finalized') {
+                    const blockHash = status.value;
+                    const [signedBlock, blockEvents] = await Promise.all([
+                        this.api.rpc.chain_getBlock(blockHash),
+                        this.getSystemEventsAt(blockHash),
+                    ]);
+                    const txIndex = signedBlock.block.extrinsics.indexOf(txHex);
+                    (0, utils_1.assert)(txIndex >= 0, 'Extrinsic not found!');
+                    const events = blockEvents.filter(({ phase }) => phase.tag === 'ApplyExtrinsic' && phase.value === txIndex);
+                    return callback(new SubmittableResult_js_1.SubmittableResult({ status, txHash, events, txIndex }));
+                }
+                else {
+                    return callback(new SubmittableResult_js_1.SubmittableResult({ status, txHash }));
+                }
+            });
+        }
+        else {
+            return this.api.rpc.author_submitExtrinsic(txHex);
+        }
+    }
+}
+exports.SubmittableExtrinsic = SubmittableExtrinsic;

package/cjs/extrinsic/submittable/SubmittableExtrinsicV2.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmittableExtrinsicV2 = void 0;
+const utils_1 = require("@dedot/utils");
+const BaseSubmittableExtrinsic_js_1 = require("./BaseSubmittableExtrinsic.js");
+const SubmittableResult_js_1 = require("./SubmittableResult.js");
+const errors_js_1 = require("./errors.js");
+/**
+ * @name SubmittableExtrinsicV2
+ * @description Submittable extrinsic based on JSON-RPC v2
+ */
+class SubmittableExtrinsicV2 extends BaseSubmittableExtrinsic_js_1.BaseSubmittableExtrinsic {
+    api;
+    constructor(api, call) {
+        super(api, call);
+        this.api = api;
+    }
+    async #send(callback) {
+        const api = this.api;
+        const txHex = this.toHex();
+        const txHash = this.hash;
+        // validate the transaction
+        // https://github.com/paritytech/json-rpc-interface-spec/issues/55#issuecomment-1609011150
+        const finalizedHash = await this.api.chainHead.finalizedHash();
+        const validateTx = async (hash) => {
+            const apiAt = await api.at(hash);
+            return apiAt.call.taggedTransactionQueue.validateTransaction('External', txHex, hash);
+        };
+        const validation = await validateTx(finalizedHash);
+        if (validation.isOk) {
+            callback(new SubmittableResult_js_1.SubmittableResult({ status: { tag: 'Validated' }, txHash }));
+        }
+        else if (validation.isErr) {
+            throw new errors_js_1.InvalidTxError(`Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}`, validation);
+        }
+        const checkTxIsOnChain = async (blockHash) => {
+            if (blockHash === finalizedHash)
+                return;
+            const txs = await api.chainHead.body(blockHash);
+            const txIndex = txs.indexOf(txHex);
+            if (txIndex < 0) {
+                return checkTxIsOnChain(api.chainHead.findBlock(blockHash).parent);
+            }
+            const events = await this.getSystemEventsAt(blockHash);
+            const txEvents = events.filter(({ phase }) => phase.tag == 'ApplyExtrinsic' && phase.value === txIndex);
+            return {
+                blockHash,
+                index: txIndex,
+                events: txEvents,
+            };
+        };
+        let txFound;
+        let isSearching = false;
+        let searchQueue = new utils_1.AsyncQueue();
+        // TODO 1. move the searching logic into a different utility
+        //      2. properly cancel the work by actually cancel the on-going operations
+        const cancelPendingSearch = () => {
+            searchQueue.clear();
+        };
+        const cancelBodySearch = () => {
+            searchQueue.cancel();
+        };
+        const startSearching = (block) => {
+            return searchQueue.enqueue(async () => {
+                const found = await checkTxIsOnChain(block.hash);
+                if (found) {
+                    cancelPendingSearch();
+                }
+                return found;
+            });
+        };
+        const checkBestBlockIncluded = async (block, bestChainChanged) => {
+            if (bestChainChanged) {
+                if (isSearching) {
+                    // if the best chain is changing, we cancel the current search
+                    // and start searching on the current best chain
+                    cancelBodySearch();
+                }
+            }
+            else {
+                if (txFound)
+                    return;
+            }
+            try {
+                isSearching = true;
+                const inBlock = await startSearching(block);
+                if (!inBlock) {
+                    if (txFound && bestChainChanged) {
+                        txFound = undefined;
+                        callback(new SubmittableResult_js_1.SubmittableResult({
+                            status: { tag: 'NoLongerInBestChain' },
+                            txHash,
+                        }));
+                    }
+                    return;
+                }
+                if (txFound && bestChainChanged) {
+                    if (txFound.blockHash === inBlock.blockHash)
+                        return;
+                }
+                txFound = inBlock;
+                const { index: txIndex, events, blockHash } = inBlock;
+                callback(new SubmittableResult_js_1.SubmittableResult({
+                    status: { tag: 'BestChainBlockIncluded', value: { blockHash, txIndex } },
+                    txHash,
+                    events,
+                    txIndex,
+                }));
+            }
+            catch {
+                // ignore this!
+            }
+            finally {
+                if (searchQueue.size === 0 && !searchQueue.isWorking) {
+                    isSearching = false;
+                }
+            }
+        };
+        let txUnsub;
+        // This whole thing is just to make sure
+        // that we're not calling stopBroadcastFn twice
+        let stopBroadcastFn;
+        let stopped = false;
+        const stopBroadcast = () => {
+            if (stopped)
+                return;
+            if (stopBroadcastFn) {
+                stopped = true;
+                stopBroadcastFn().catch(utils_1.noop);
+            }
+        };
+        const checkFinalizedBlockIncluded = async (block) => {
+            const inBlock = await checkTxIsOnChain(block.hash);
+            if (inBlock) {
+                const { index: txIndex, events, blockHash } = inBlock;
+                callback(new SubmittableResult_js_1.SubmittableResult({
+                    status: { tag: 'Finalized', value: { blockHash, txIndex } },
+                    txHash,
+                    events,
+                    txIndex,
+                }));
+            }
+            else {
+                // Revalidate the tx, just in-case it becomes invalid along the way
+                // Context: https://github.com/paritytech/json-rpc-interface-spec/pull/107#issuecomment-1906008814
+                const validation = await validateTx(block.hash);
+                if (validation.isOk)
+                    return;
+                callback(new SubmittableResult_js_1.SubmittableResult({
+                    status: {
+                        tag: 'Invalid',
+                        value: { error: `Invalid Tx: ${validation.err.tag} - ${validation.err.value.tag}` },
+                    },
+                    txHash,
+                }));
+            }
+            txUnsub().catch(utils_1.noop);
+        };
+        stopBroadcastFn = await api.txBroadcaster.broadcastTx(txHex);
+        callback(new SubmittableResult_js_1.SubmittableResult({
+            status: { tag: 'Broadcasting' },
+            txHash,
+        }));
+        const stopBestBlockTrackingFn = api.chainHead.on('bestBlock', checkBestBlockIncluded);
+        const stopFinalizedBlockTrackingFn = api.chainHead.on('finalizedBlock', checkFinalizedBlockIncluded);
+        const stopTracking = () => {
+            stopBestBlockTrackingFn();
+            stopFinalizedBlockTrackingFn();
+            cancelBodySearch();
+        };
+        txUnsub = async () => {
+            stopTracking();
+            stopBroadcast();
+        };
+        return txUnsub;
+    }
+    async send(callback) {
+        const isSubscription = !!callback;
+        if (isSubscription) {
+            return this.#send(callback);
+        }
+        else {
+            const defer = (0, utils_1.deferred)();
+            try {
+                // TODO handle timeout for this with the Drop status, just in-case we somehow can't find the tx in any block
+                const unsub = await this.#send(({ status, txHash }) => {
+                    if (status.tag === 'BestChainBlockIncluded' || status.tag === 'Finalized') {
+                        defer.resolve(txHash);
+                        unsub().catch(utils_1.noop);
+                    }
+                    else if (status.tag === 'Invalid' || status.tag === 'Drop') {
+                        defer.reject(new Error(status.value.error));
+                        unsub().catch(utils_1.noop);
+                    }
+                });
+            }
+            catch (e) {
+                defer.reject(e);
+            }
+            return defer.promise;
+        }
+    }
+}
+exports.SubmittableExtrinsicV2 = SubmittableExtrinsicV2;

package/cjs/extrinsic/submittable/SubmittableResult.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubmittableResult = void 0;
+class SubmittableResult {
+    status;
+    events;
+    dispatchInfo;
+    dispatchError;
+    txHash;
+    txIndex;
+    constructor({ events, status, txHash, txIndex }) {
+        this.events = events || [];
+        this.status = status;
+        this.txHash = txHash;
+        this.txIndex = txIndex;
+        [this.dispatchInfo, this.dispatchError] = this._extractDispatchInfo();
+    }
+    _extractDispatchInfo() {
+        for (const { event } of this.events) {
+            const { pallet, palletEvent } = event;
+            if (pallet === 'System' && palletEvent.name === 'ExtrinsicFailed') {
+                const { dispatchInfo, dispatchError } = palletEvent.data;
+                return [dispatchInfo, dispatchError];
+            }
+            else if (pallet === 'System' && palletEvent.name === 'ExtrinsicSuccess') {
+                const { dispatchInfo } = palletEvent.data;
+                return [dispatchInfo, undefined];
+            }
+        }
+        return [undefined, undefined];
+    }
+}
+exports.SubmittableResult = SubmittableResult;

package/cjs/extrinsic/submittable/errors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTxError = void 0;
+const utils_1 = require("@dedot/utils");
+/**
+ * This throws out if the extrinsic is invalid
+ * after verifying via `call.taggedTransactionQueue.validateTransaction`
+ */
+class InvalidTxError extends utils_1.DedotError {
+    data;
+    constructor(message, data) {
+        super(message);
+        this.data = data;
+    }
+}
+exports.InvalidTxError = InvalidTxError;

package/cjs/extrinsic/submittable/fakeSigner.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fakeSigner = void 0;
+const utils_1 = require("@dedot/utils");
+const FAKE_SIGNATURE = new Uint8Array(64 * 8).fill(0);
+exports.fakeSigner = {
+    signPayload: async () => {
+        return {
+            id: Date.now(),
+            signature: (0, utils_1.u8aToHex)(FAKE_SIGNATURE),
+        };
+    },
+};

package/cjs/extrinsic/submittable/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("./errors.js"), exports);
+__exportStar(require("./SubmittableResult.js"), exports);
+__exportStar(require("./SubmittableExtrinsic.js"), exports);
+__exportStar(require("./SubmittableExtrinsicV2.js"), exports);

package/cjs/extrinsic/submittable/utils.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signRaw = exports.isKeyringPair = void 0;
+const utils_1 = require("@dedot/utils");
+function isKeyringPair(account) {
+    return (0, utils_1.isFunction)(account.sign);
+}
+exports.isKeyringPair = isKeyringPair;
+/**
+ * Sign a raw message
+ * @param signerPair
+ * @param raw
+ */
+function signRaw(signerPair, raw) {
+    const u8a = (0, utils_1.hexToU8a)(raw);
+    // Ref: https://github.com/paritytech/polkadot-sdk/blob/943697fa693a4da6ef481ef93df522accb7d0583/substrate/primitives/runtime/src/generic/unchecked_extrinsic.rs#L234-L238
+    const toSignRaw = u8a.length > 256 ? (0, utils_1.blake2AsU8a)(u8a, 256) : u8a;
+    return signerPair.sign(toSignRaw, { withType: true });
+}
+exports.signRaw = signRaw;

package/cjs/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("./storage/index.js"), exports);
+__exportStar(require("./extrinsic/index.js"), exports);
+__exportStar(require("./executor/index.js"), exports);
+__exportStar(require("./json-rpc/index.js"), exports);
+__exportStar(require("./client/index.js"), exports);

package/cjs/json-rpc/JsonRpcClient.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonRpcClient = exports.isJsonRpcProvider = void 0;
+const utils_1 = require("@dedot/utils");
+const scaledResponses_js_1 = require("./scaledResponses.js");
+const subscriptionsInfo_js_1 = require("./subscriptionsInfo.js");
+const isJsonRpcProvider = (provider) => {
+    return (provider &&
+        (0, utils_1.isString)(provider.status) &&
+        (0, utils_1.isFunction)(provider.send) &&
+        (0, utils_1.isFunction)(provider.subscribe) &&
+        (0, utils_1.isFunction)(provider.connect) &&
+        (0, utils_1.isFunction)(provider.disconnect));
+};
+exports.isJsonRpcProvider = isJsonRpcProvider;
+class JsonRpcClient extends utils_1.EventEmitter {
+    #options;
+    #provider;
+    constructor(options) {
+        super();
+        if ((0, exports.isJsonRpcProvider)(options)) {
+            this.#options = { provider: options };
+            this.#provider = options;
+        }
+        else {
+            this.#options = options;
+            this.#provider = options.provider;
+        }
+        (0, utils_1.assert)(this.#provider, 'A JsonRpcProvider is required');
+    }
+    /**
+     * Factory method to create a new JsonRpcClient instance
+     *
+     * @param options
+     */
+    static async create(options) {
+        return new JsonRpcClient(options).connect();
+    }
+    /**
+     * Alias for __JsonRpcClient.create__
+     *
+     * @param options
+     */
+    static async new(options) {
+        return JsonRpcClient.create(options);
+    }
+    get options() {
+        return this.#options;
+    }
+    /**
+     * @description Check connection status of the api instance
+     */
+    get status() {
+        return this.provider.status;
+    }
+    /**
+     * @description Get the JSON-RPC provider instance
+     */
+    get provider() {
+        return this.#provider;
+    }
+    connect() {
+        return this.#doConnect();
+    }
+    async #doConnect() {
+        this.provider.on('connected', this.#onConnected);
+        this.provider.on('disconnected', this.#onDisconnected);
+        this.provider.on('reconnecting', this.#onReconnecting);
+        this.provider.on('error', this.#onError);
+        return new Promise((resolve, reject) => {
+            // @ts-ignore
+            this.once('connected', () => {
+                resolve(this);
+            });
+            if (this.status === 'connected') {
+                this.#onConnected().catch(reject);
+            }
+            else {
+                this.provider.connect().catch(reject);
+            }
+        });
+    }
+    #onConnected = async () => {
+        // @ts-ignore
+        this.emit('connected');
+    };
+    #onDisconnected = async () => {
+        // @ts-ignore
+        this.emit('disconnected');
+    };
+    #onReconnecting = async () => {
+        // @ts-ignore
+        this.emit('reconnecting');
+    };
+    #onError = async (e) => {
+        // @ts-ignore
+        this.emit('error', e);
+    };
+    async disconnect() {
+        await this.#provider.disconnect();
+        this.clearEvents();
+    }
+    /**
+     * @description Entry-point for executing JSON-RPCs to blockchain node.
+     *
+     * ```typescript
+     * const client = new JsonRpcClient('wss://rpc.polkadot.io');
+     * await client.connect();
+     *
+     * // Subscribe to new heads
+     * client.rpc.chain_subscribeNewHeads((header) => {
+     *   console.log(header);
+     * });
+     *
+     * // Execute arbitrary rpc method: `module_rpc_name`
+     * const result = await client.rpc.module_rpc_name();
+     * ```
+     */
+    get rpc() {
+        return new Proxy(this, {
+            get(target, property, receiver) {
+                const rpcMethod = property.toString();
+                return target.#doExecute(rpcMethod);
+            },
+        });
+    }
+    #doExecute(rpcName) {
+        const subscriptionInfo = this.options.subscriptions?.[rpcName] || subscriptionsInfo_js_1.subscriptionsInfo[rpcName];
+        const isSubscription = !!subscriptionInfo;
+        const fnRpc = async (...args) => {
+            const result = await this.provider.send(rpcName, args);
+            return this.#tryDecode(rpcName, result);
+        };
+        const fnSubRpc = async (...args) => {
+            const inArgs = args.slice();
+            const callback = inArgs.pop();
+            (0, utils_1.assert)((0, utils_1.isFunction)(callback), 'A callback is required for subscription');
+            const onNewMessage = (error, result, subscription) => {
+                if (error) {
+                    console.error(error);
+                    return;
+                }
+                callback(this.#tryDecode(rpcName, result), subscription);
+            };
+            const [subname, unsubscribe] = subscriptionInfo;
+            const subscription = await this.provider.subscribe({ subname, subscribe: rpcName, params: inArgs, unsubscribe }, onNewMessage);
+            return async () => {
+                await subscription.unsubscribe();
+            };
+        };
+        return isSubscription ? fnSubRpc : fnRpc;
+    }
+    #tryDecode(rpcName, raw) {
+        if (raw === null) {
+            // We use `undefined` to represent Option::None in the client
+            return undefined;
+        }
+        const $maybeCodec = this.options.scaledResponses?.[rpcName] || scaledResponses_js_1.scaledResponses[rpcName];
+        if ($maybeCodec) {
+            return $maybeCodec.tryDecode(raw);
+        }
+        return raw;
+    }
+}
+exports.JsonRpcClient = JsonRpcClient;

package/cjs/json-rpc/group/ChainHead/BlockUsage.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockUsage = void 0;
+/**
+ * A helper to track block hash usage
+ */
+class BlockUsage {
+    #usages = {};
+    use(blockHash) {
+        this.#usages[blockHash] = (this.#usages[blockHash] || 0) + 1;
+    }
+    release(blockHash) {
+        if (!this.#usages[blockHash])
+            return;
+        this.#usages[blockHash] -= 1;
+    }
+    usage(blockHash) {
+        return this.#usages[blockHash] || 0;
+    }
+    clear() {
+        this.#usages = {};
+    }
+}
+exports.BlockUsage = BlockUsage;