@acala-network/chopsticks-core 0.8.3 → 0.8.4

package/lib/rpc/substrate/author.d.ts

@@ -0,0 +1,28 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+export declare const author_submitExtrinsic: Handler<[HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const author_submitAndWatchExtrinsic: Handler<[HexString], string>;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+export declare const author_unwatchExtrinsic: Handler<[string], void>;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+export declare const author_pendingExtrinsics: Handler<void, HexString[]>;

package/lib/rpc/substrate/author.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author_pendingExtrinsics = exports.author_unwatchExtrinsic = exports.author_submitAndWatchExtrinsic = exports.author_submitExtrinsic = void 0;
+const txpool_1 = require("../../blockchain/txpool");
+const shared_1 = require("../shared");
+const logger_1 = require("../../logger");
+const logger = logger_1.defaultLogger.child({ name: 'rpc-author' });
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return Hash
+ */
+const author_submitExtrinsic = (context, [extrinsic]) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.submitExtrinsic(extrinsic).catch((error) => {
+        const code = error.isInvalid ? 1010 : 1011;
+        throw new shared_1.ResponseError(code, error.toString());
+    });
+});
+exports.author_submitExtrinsic = author_submitExtrinsic;
+/**
+ * @param context
+ * @param params - [`extrinsic`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+const author_submitAndWatchExtrinsic = (context, [extrinsic], { subscribe, unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = (_block) => { };
+    const id = context.chain.headState.subscribeHead((block) => update(block));
+    const callback = subscribe('author_extrinsicUpdate', id, () => context.chain.headState.unsubscribeHead(id));
+    const onExtrinsicFail = ([failedExtrinsic, error]) => {
+        if (failedExtrinsic === extrinsic) {
+            callback(error.toJSON());
+            done(id);
+        }
+    };
+    context.chain.txPool.event.on(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+    const done = (id) => {
+        context.chain.txPool.event.removeListener(txpool_1.APPLY_EXTRINSIC_ERROR, onExtrinsicFail);
+        unsubscribe(id);
+    };
+    update = (block) => __awaiter(void 0, void 0, void 0, function* () {
+        const extrisnics = yield block.extrinsics;
+        if (!extrisnics.includes(extrinsic))
+            return;
+        logger.debug({ block: block.hash }, 'author_extrinsicUpdate');
+        callback({
+            inBlock: block.hash,
+        });
+        // wait a bit for InBlock to be sent
+        yield new Promise((r) => setTimeout(r, 100));
+        callback({
+            finalized: block.hash,
+        });
+        done(id);
+    });
+    try {
+        yield context.chain.submitExtrinsic(extrinsic);
+        callback({
+            ready: null,
+        });
+    }
+    catch (error) {
+        logger.error({ error }, 'ExtrinsicFailed');
+        const code = error.isInvalid ? 1010 : 1011;
+        done(id);
+        throw new shared_1.ResponseError(code, error.toString());
+    }
+    return id;
+});
+exports.author_submitAndWatchExtrinsic = author_submitAndWatchExtrinsic;
+/**
+ * @param _context
+ * @param params - [`subid`]
+ */
+const author_unwatchExtrinsic = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.author_unwatchExtrinsic = author_unwatchExtrinsic;
+/**
+ * Get pending extrinsics
+ *
+ * @return Array of pending extrinsics
+ */
+const author_pendingExtrinsics = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.txPool.pendingExtrinsics;
+});
+exports.author_pendingExtrinsics = author_pendingExtrinsics;

package/lib/rpc/substrate/chain.d.ts

@@ -0,0 +1,45 @@
+import { Header } from '@polkadot/types/interfaces';
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+export declare const chain_getBlockHash: Handler<[number | number[] | null], HexString | (HexString | null)[] | null>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+export declare const chain_getHeader: Handler<[HexString], Header>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+export declare const chain_getBlock: Handler<[
+    HexString
+], {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications: null;
+}>;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+export declare const chain_getFinalizedHead: Handler<void, HexString>;
+export declare const chain_subscribeNewHead: Handler<void, string>;
+export declare const chain_subscribeFinalizedHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHead: Handler<[string], void>;
+export declare const chain_getHead: Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+export declare const chain_subscribeNewHeads: Handler<void, string>;
+export declare const chain_unsubscribeNewHeads: Handler<[string], void>;
+export declare const chain_unsubscribeFinalizedHeads: Handler<[string], void>;

package/lib/rpc/substrate/chain.js

@@ -0,0 +1,103 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain_unsubscribeFinalizedHeads = exports.chain_unsubscribeNewHeads = exports.chain_subscribeNewHeads = exports.chain_getHead = exports.chain_unsubscribeNewHead = exports.chain_subscribeFinalizedHeads = exports.chain_subscribeNewHead = exports.chain_getFinalizedHead = exports.chain_getBlock = exports.chain_getHeader = exports.chain_getBlockHash = void 0;
+const shared_1 = require("../shared");
+const processHeader = (header) => {
+    const res = header.toJSON();
+    res.number = '0x' + res.number.toString(16); // number is hex format
+    return res;
+};
+/**
+ * @param context
+ * @param params - [`blockNumber` | `blockNumber[]` | null]
+ *
+ * @return Block hash | hash[] | null
+ */
+const chain_getBlockHash = (context, [blockNumber]) => __awaiter(void 0, void 0, void 0, function* () {
+    const numbers = Array.isArray(blockNumber) ? blockNumber : [blockNumber];
+    const hashes = yield Promise.all(numbers.map((n) => context.chain.getBlockAt(n))).then((blocks) => blocks.map((b) => (b === null || b === void 0 ? void 0 : b.hash) || null));
+    return Array.isArray(blockNumber) ? hashes : hashes[0];
+});
+exports.chain_getBlockHash = chain_getBlockHash;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Header - see `@polkadot/types/interfaces`
+ */
+const chain_getHeader = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return processHeader(yield block.header);
+});
+exports.chain_getHeader = chain_getHeader;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return Block header and extrinsics
+ */
+const chain_getBlock = (context, [hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    return {
+        block: {
+            header: yield block.header,
+            extrinsics: yield block.extrinsics,
+        },
+        justifications: null,
+    };
+});
+exports.chain_getBlock = chain_getBlock;
+/**
+ * @param context
+ *
+ * @return head hash
+ */
+const chain_getFinalizedHead = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    return context.chain.head.hash;
+});
+exports.chain_getFinalizedHead = chain_getFinalizedHead;
+const chain_subscribeNewHead = (context, _params, { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_newHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = () => __awaiter(void 0, void 0, void 0, function* () {
+        callback(processHeader(yield context.chain.head.header));
+    });
+    update();
+    return id;
+});
+exports.chain_subscribeNewHead = chain_subscribeNewHead;
+const chain_subscribeFinalizedHeads = (context, _params, { subscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    let update = () => { };
+    const id = context.chain.headState.subscribeHead(() => update());
+    const callback = subscribe('chain_finalizedHead', id, () => context.chain.headState.unsubscribeHead(id));
+    update = () => __awaiter(void 0, void 0, void 0, function* () {
+        callback(processHeader(yield context.chain.head.header));
+    });
+    update();
+    return id;
+});
+exports.chain_subscribeFinalizedHeads = chain_subscribeFinalizedHeads;
+const chain_unsubscribeNewHead = (_context, [subid], { unsubscribe }) => __awaiter(void 0, void 0, void 0, function* () {
+    unsubscribe(subid);
+});
+exports.chain_unsubscribeNewHead = chain_unsubscribeNewHead;
+exports.chain_getHead = exports.chain_getBlockHash;
+exports.chain_subscribeNewHeads = exports.chain_subscribeNewHead;
+exports.chain_unsubscribeNewHeads = exports.chain_unsubscribeNewHead;
+exports.chain_unsubscribeFinalizedHeads = exports.chain_unsubscribeNewHead;

package/lib/rpc/substrate/index.d.ts

@@ -0,0 +1,66 @@
+import * as AuthorRPC from './author';
+import * as ChainRPC from './chain';
+import * as PaymentRPC from './payment';
+import * as StateRPC from './state';
+import * as SystemRPC from './system';
+export { AuthorRPC };
+export { ChainRPC };
+export { PaymentRPC };
+export { StateRPC };
+export { SystemRPC };
+declare const handlers: {
+    system_localPeerId: () => Promise<string>;
+    system_nodeRoles: () => Promise<string[]>;
+    system_localListenAddresses: () => Promise<never[]>;
+    system_chain: import("..").Handler<void, string>;
+    system_properties: import("..").Handler<void, import("../..").ChainProperties>;
+    system_name: import("..").Handler<void, string>;
+    system_version: import("..").Handler<void, string>;
+    system_chainType: import("..").Handler<void, string>;
+    system_health: () => Promise<{
+        peers: number;
+        isSyncing: boolean;
+        shouldHavePeers: boolean;
+    }>;
+    system_dryRun: import("..").Handler<[`0x${string}`, `0x${string}`], string>;
+    system_accountNextIndex: import("..").Handler<[`0x${string}`], number>;
+    state_getRuntimeVersion: import("..").Handler<[`0x${string}`], import("../..").RuntimeVersion | undefined>;
+    state_getMetadata: import("..").Handler<[`0x${string}`], `0x${string}` | undefined>;
+    state_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`], string | undefined>;
+    state_getKeysPaged: import("..").Handler<[string, number, string, `0x${string}`], string[] | undefined>;
+    state_queryStorageAt: import("..").Handler<[string[], `0x${string}`], [] | [{
+        block: `0x${string}`;
+        changes: (string | undefined)[][];
+    }]>;
+    state_call: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], `0x${string}`>;
+    state_subscribeRuntimeVersion: import("..").Handler<[], string>;
+    state_unsubscribeRuntimeVersion: import("..").Handler<[`0x${string}`], void>;
+    state_subscribeStorage: import("..").Handler<[string[]], string>;
+    state_unsubscribeStorage: import("..").Handler<[string], void>;
+    childstate_getStorage: import("..").Handler<[`0x${string}`, `0x${string}`, `0x${string}`], string | undefined>;
+    childstate_getKeysPaged: import("..").Handler<[`0x${string}`, `0x${string}`, number, `0x${string}`, `0x${string}`], `0x${string}`[] | undefined>;
+    payment_queryFeeDetails: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    payment_queryInfo: import("..").Handler<[`0x${string}`, `0x${string}`], `0x${string}`>;
+    chain_getBlockHash: import("..").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_getHeader: import("..").Handler<[`0x${string}`], import("@polkadot/types/interfaces").Header>;
+    chain_getBlock: import("..").Handler<[`0x${string}`], {
+        block: {
+            header: import("@polkadot/types/interfaces").Header;
+            extrinsics: `0x${string}`[];
+        };
+        justifications: null;
+    }>;
+    chain_getFinalizedHead: import("..").Handler<void, `0x${string}`>;
+    chain_subscribeNewHead: import("..").Handler<void, string>;
+    chain_subscribeFinalizedHeads: import("..").Handler<void, string>;
+    chain_unsubscribeNewHead: import("..").Handler<[string], void>;
+    chain_getHead: import("..").Handler<[number | number[] | null], `0x${string}` | (`0x${string}` | null)[] | null>;
+    chain_subscribeNewHeads: import("..").Handler<void, string>;
+    chain_unsubscribeNewHeads: import("..").Handler<[string], void>;
+    chain_unsubscribeFinalizedHeads: import("..").Handler<[string], void>;
+    author_submitExtrinsic: import("..").Handler<[`0x${string}`], `0x${string}`>;
+    author_submitAndWatchExtrinsic: import("..").Handler<[`0x${string}`], string>;
+    author_unwatchExtrinsic: import("..").Handler<[string], void>;
+    author_pendingExtrinsics: import("..").Handler<void, `0x${string}`[]>;
+};
+export default handlers;

package/lib/rpc/substrate/index.js

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemRPC = exports.StateRPC = exports.PaymentRPC = exports.ChainRPC = exports.AuthorRPC = void 0;
+const AuthorRPC = __importStar(require("./author"));
+exports.AuthorRPC = AuthorRPC;
+const ChainRPC = __importStar(require("./chain"));
+exports.ChainRPC = ChainRPC;
+const PaymentRPC = __importStar(require("./payment"));
+exports.PaymentRPC = PaymentRPC;
+const StateRPC = __importStar(require("./state"));
+exports.StateRPC = StateRPC;
+const SystemRPC = __importStar(require("./system"));
+exports.SystemRPC = SystemRPC;
+const handlers = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, AuthorRPC), ChainRPC), PaymentRPC), StateRPC), SystemRPC);
+exports.default = handlers;

package/lib/rpc/substrate/payment.d.ts

@@ -0,0 +1,16 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryFeeDetails: Handler<[HexString, HexString], HexString>;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const payment_queryInfo: Handler<[HexString, HexString], HexString>;

package/lib/rpc/substrate/payment.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.payment_queryInfo = exports.payment_queryFeeDetails = void 0;
+const util_1 = require("@polkadot/util");
+const shared_1 = require("../shared");
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryFeeDetails = (context, [extrinsic, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = yield block.registry;
+    const tx = (0, util_1.hexToU8a)(extrinsic);
+    const resp = yield block.call('TransactionPaymentApi_query_fee_details', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+});
+exports.payment_queryFeeDetails = payment_queryFeeDetails;
+/**
+ * @param context
+ * @param params - [`extrinsic`, `blockhash`]
+ *
+ * @return result in hash
+ */
+const payment_queryInfo = (context, [extrinsic, hash]) => __awaiter(void 0, void 0, void 0, function* () {
+    const block = yield context.chain.getBlock(hash);
+    if (!block) {
+        throw new shared_1.ResponseError(1, `Block ${hash} not found`);
+    }
+    const registry = yield block.registry;
+    const tx = (0, util_1.hexToU8a)(extrinsic);
+    const resp = yield block.call('TransactionPaymentApi_query_info', [
+        registry.createType('Extrinsic', tx).toHex(),
+        registry.createType('u32', tx.byteLength).toHex(),
+    ]);
+    return resp.result;
+});
+exports.payment_queryInfo = payment_queryInfo;

package/lib/rpc/substrate/state.d.ts

@@ -0,0 +1,97 @@
+import { HexString } from '@polkadot/util/types';
+import { Handler } from '../shared';
+import { RuntimeVersion } from '../../wasm-executor';
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return runtime version
+ */
+export declare const state_getRuntimeVersion: Handler<[HexString], RuntimeVersion | undefined>;
+/**
+ * @param context
+ * @param params - [`blockhash`]
+ *
+ * @return metadata
+ */
+export declare const state_getMetadata: Handler<[HexString], HexString | undefined>;
+/**
+ * @param context
+ * @param params - [`key`, `blockhash`]
+ *
+ * @return storage value
+ */
+export declare const state_getStorage: Handler<[HexString, HexString], string | undefined>;
+/**
+ * @param context
+ * @param params - [`prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const state_getKeysPaged: Handler<[string, number, string, HexString], string[] | undefined>;
+/**
+ * @param context
+ * @param params - [`keys`, `blockhash`]
+ *
+ * @return storage values
+ */
+export declare const state_queryStorageAt: Handler<[
+    string[],
+    HexString
+], [] | [
+    {
+        block: HexString;
+        changes: (string | undefined)[][];
+    }
+]>;
+/**
+ * @param context
+ * @param params - [`method`, `data`, `blockhash`]
+ *
+ * @return result in hash
+ */
+export declare const state_call: Handler<[HexString, HexString, HexString], HexString>;
+/**
+ * @return subscription id
+ */
+export declare const state_subscribeRuntimeVersion: Handler<[], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeRuntimeVersion: Handler<[HexString], void>;
+/**
+ * @param context
+ * @param params - [`keys`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const state_subscribeStorage: Handler<[string[]], string>;
+/**
+ * @param context
+ * @param params - [`subid`]
+ * @param subscriptionManager
+ */
+export declare const state_unsubscribeStorage: Handler<[string], void>;
+/**
+ * @param context
+ * @param params - [`child`, `key`, `blockhash`]
+ *
+ * @return storage valuse
+ */
+export declare const childstate_getStorage: Handler<[HexString, HexString, HexString], string | undefined>;
+/**
+ * @param context
+ * @param params - [`child`, `prefix`, `pageSize`, `startKey`, `blockhash`]
+ *
+ * @return paged keys
+ */
+export declare const childstate_getKeysPaged: Handler<[
+    HexString,
+    HexString,
+    number,
+    HexString,
+    HexString
+], HexString[] | undefined>;