@acala-network/chopsticks-core 0.8.5-5 → 0.9.0

package/{lib → dist/cjs}/api.js

@@ -79,13 +79,13 @@ class Api {
         return __classPrivateFieldGet(this, _Api_provider, "f").send('system_chain', []);
     }
     async getBlockHash(blockNumber) {
-        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : []);
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : [], !!blockNumber);
     }
     async getHeader(hash) {
-        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : []);
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : [], !!hash);
     }
     async getBlock(hash) {
-        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : []);
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : [], !!hash);
     }
     async getStorage(key, hash) {
         const [child, storageKey] = (0, utils_1.splitChildKey)(key);
@@ -94,14 +94,14 @@ class Api {
             const params = [child, storageKey];
             if (hash)
                 params.push(hash);
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('childstate_getStorage', params);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('childstate_getStorage', params, !!hash);
         }
         else {
             // main storage key, use state_getStorage
             const params = [key];
             if (hash)
                 params.push(hash);
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params, !!hash);
         }
     }
     async getKeysPaged(prefix, pageSize, startKey, hash) {
@@ -113,7 +113,7 @@ class Api {
             if (hash)
                 params.push(hash);
             return __classPrivateFieldGet(this, _Api_provider, "f")
-                .send('childstate_getKeysPaged', params)
+                .send('childstate_getKeysPaged', params, !!hash)
                 .then((keys) => keys.map((key) => (0, utils_1.prefixedChildKey)(child, key)));
         }
         else {
@@ -121,7 +121,7 @@ class Api {
             const params = [prefix, pageSize, startKey];
             if (hash)
                 params.push(hash);
-            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params, !!hash);
         }
     }
 }

package/{lib → dist/cjs}/blockchain/block.js

@@ -19,7 +19,6 @@ const util_1 = require("@polkadot/types-known/util");
 const util_2 = require("@polkadot/util");
 const storage_layer_1 = require("./storage-layer");
 const utils_1 = require("../utils");
-const logger_1 = require("../logger");
 const wasm_executor_1 = require("../wasm-executor");
 /**
  * Block class.
@@ -264,9 +263,7 @@ class Block {
             runtimeLogLevel: __classPrivateFieldGet(this, _Block_chain, "f").runtimeLogLevel,
         }, (0, wasm_executor_1.taskHandler)(this));
         if ('Call' in response) {
-            for (const log of response.Call.runtimeLogs) {
-                logger_1.defaultLogger.info(`RuntimeLogs:\n${log}`);
-            }
+            (0, utils_1.printRuntimeLogs)(response.Call.runtimeLogs);
             if (this.chain.offchainWorker) {
                 // apply offchain storage
                 for (const [key, value] of response.Call.offchainStorageDiff) {

package/{lib → dist/cjs}/genesis-provider.js

@@ -53,7 +53,7 @@ class GenesisProvider {
         this.getHeader = async () => {
             return {
                 blockHash: this.blockHash,
-                number: 0,
+                number: '0x0',
                 stateRoot: await __classPrivateFieldGet(this, _GenesisProvider_stateRoot, "f"),
                 digest: {
                     logs: [],

package/{lib → dist/cjs}/rpc/substrate/chain.js

@@ -46,7 +46,7 @@ const chain_getBlock = async (context, [hash]) => {
     }
     return {
         block: {
-            header: await block.header,
+            header: processHeader(await block.header),
             extrinsics: await block.extrinsics,
         },
         justifications: null,

package/{lib → dist/cjs}/utils/index.js

@@ -14,7 +14,7 @@ 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.stripChildPrefix = exports.splitChildKey = exports.isPrefixedChildKey = exports.prefixedChildKey = exports.defer = exports.isUrl = exports.getParaId = exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
+exports.printRuntimeLogs = exports.stripChildPrefix = exports.splitChildKey = exports.isPrefixedChildKey = exports.prefixedChildKey = exports.defer = exports.isUrl = exports.getParaId = exports.compactHex = exports.fetchKeysToArray = exports.fetchKeys = void 0;
 const util_1 = require("@polkadot/util");
 const hex_1 = require("@polkadot/util/hex");
 __exportStar(require("./set-storage"), exports);
@@ -107,3 +107,13 @@ const stripChildPrefix = (key) => {
     return storageKey;
 };
 exports.stripChildPrefix = stripChildPrefix;
+const printRuntimeLogs = (logs) => {
+    if (!logs.length)
+        return;
+    console.group('RuntimeLogs:');
+    for (const log of logs) {
+        console.log(log);
+    }
+    console.groupEnd();
+};
+exports.printRuntimeLogs = printRuntimeLogs;

package/dist/esm/api.js

@@ -0,0 +1,125 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Api_provider, _Api_ready, _Api_chain, _Api_chainProperties;
+import { prefixedChildKey, splitChildKey, stripChildPrefix } from './utils';
+/**
+ * API class. Calls provider to get on-chain data.
+ * Either `endpoint` or `genesis` porvider must be provided.
+ *
+ * @example Instantiate an API
+ *
+ * ```ts
+ * const provider = new WsProvider(options.endpoint)
+ * const api = new Api(provider)
+ * await api.isReady
+ * ```
+ */
+export class Api {
+    constructor(provider, signedExtensions) {
+        _Api_provider.set(this, void 0);
+        _Api_ready.set(this, void 0);
+        _Api_chain.set(this, void 0);
+        _Api_chainProperties.set(this, void 0);
+        __classPrivateFieldSet(this, _Api_provider, provider, "f");
+        this.signedExtensions = signedExtensions || {};
+    }
+    async disconnect() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").disconnect();
+    }
+    get isReady() {
+        if (!__classPrivateFieldGet(this, _Api_ready, "f")) {
+            if (__classPrivateFieldGet(this, _Api_provider, "f")['isReady']) {
+                __classPrivateFieldSet(this, _Api_ready, __classPrivateFieldGet(this, _Api_provider, "f")['isReady'], "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _Api_ready, new Promise((resolve) => {
+                    if (__classPrivateFieldGet(this, _Api_provider, "f").hasSubscriptions) {
+                        __classPrivateFieldGet(this, _Api_provider, "f").on('connected', resolve);
+                        __classPrivateFieldGet(this, _Api_provider, "f").connect();
+                    }
+                    else {
+                        resolve();
+                    }
+                }), "f");
+            }
+        }
+        return __classPrivateFieldGet(this, _Api_ready, "f");
+    }
+    get chain() {
+        if (!__classPrivateFieldGet(this, _Api_chain, "f")) {
+            __classPrivateFieldSet(this, _Api_chain, this.getSystemChain(), "f");
+        }
+        return __classPrivateFieldGet(this, _Api_chain, "f");
+    }
+    get chainProperties() {
+        if (!__classPrivateFieldGet(this, _Api_chainProperties, "f")) {
+            __classPrivateFieldSet(this, _Api_chainProperties, this.getSystemProperties(), "f");
+        }
+        return __classPrivateFieldGet(this, _Api_chainProperties, "f");
+    }
+    async getSystemName() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_name', []);
+    }
+    async getSystemProperties() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_properties', []);
+    }
+    async getSystemChain() {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('system_chain', []);
+    }
+    async getBlockHash(blockNumber) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : [], !!blockNumber);
+    }
+    async getHeader(hash) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : [], !!hash);
+    }
+    async getBlock(hash) {
+        return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : [], !!hash);
+    }
+    async getStorage(key, hash) {
+        const [child, storageKey] = splitChildKey(key);
+        if (child) {
+            // child storage key, use childstate_getStorage
+            const params = [child, storageKey];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('childstate_getStorage', params, !!hash);
+        }
+        else {
+            // main storage key, use state_getStorage
+            const params = [key];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params, !!hash);
+        }
+    }
+    async getKeysPaged(prefix, pageSize, startKey, hash) {
+        const [child, storageKey] = splitChildKey(prefix);
+        if (child) {
+            // child storage key, use childstate_getKeysPaged
+            // strip child prefix from startKey
+            const params = [child, storageKey, pageSize, stripChildPrefix(startKey)];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f")
+                .send('childstate_getKeysPaged', params, !!hash)
+                .then((keys) => keys.map((key) => prefixedChildKey(child, key)));
+        }
+        else {
+            // main storage key, use state_getKeysPaged
+            const params = [prefix, pageSize, startKey];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params, !!hash);
+        }
+    }
+}
+_Api_provider = new WeakMap(), _Api_ready = new WeakMap(), _Api_chain = new WeakMap(), _Api_chainProperties = new WeakMap();

package/dist/esm/blockchain/block-builder.js

@@ -0,0 +1,293 @@
+import { Block } from './block';
+import { StorageLayer, StorageValueKind } from './storage-layer';
+import { compactAddLength, hexToU8a, stringToHex, u8aConcat } from '@polkadot/util';
+import { compactHex } from '../utils';
+import { defaultLogger, truncate } from '../logger';
+import { getCurrentSlot } from '../utils/time-travel';
+const logger = defaultLogger.child({ name: 'block-builder' });
+const getConsensus = (header) => {
+    if (header.digest.logs.length === 0)
+        return;
+    const preRuntime = header.digest.logs[0].asPreRuntime;
+    const [consensusEngine, slot] = preRuntime;
+    return { consensusEngine, slot, rest: header.digest.logs.slice(1) };
+};
+const getNewSlot = (digest, slotNumber) => {
+    if (digest.isPrimary) {
+        return {
+            primary: {
+                ...digest.asPrimary.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryPlain) {
+        return {
+            secondaryPlain: {
+                ...digest.asSecondaryPlain.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    if (digest.isSecondaryVRF) {
+        return {
+            secondaryVRF: {
+                ...digest.asSecondaryVRF.toJSON(),
+                slotNumber,
+            },
+        };
+    }
+    return digest.toJSON();
+};
+export const newHeader = async (head, unsafeBlockHeight) => {
+    const meta = await head.meta;
+    const parentHeader = await head.header;
+    let newLogs = parentHeader.digest.logs;
+    const consensus = getConsensus(parentHeader);
+    if (consensus?.consensusEngine.isAura) {
+        const slot = await getCurrentSlot(head.chain);
+        const newSlot = compactAddLength(meta.registry.createType('Slot', slot + 1).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine.isBabe) {
+        const slot = await getCurrentSlot(head.chain);
+        const digest = meta.registry.createType('RawBabePreDigest', consensus.slot);
+        const newSlot = compactAddLength(meta.registry.createType('RawBabePreDigest', getNewSlot(digest, slot + 1)).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus?.consensusEngine?.toString() == 'nmbs') {
+        const nmbsKey = stringToHex('nmbs');
+        newLogs = [
+            {
+                // Using previous block author
+                PreRuntime: [
+                    consensus.consensusEngine,
+                    parentHeader.digest.logs
+                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)
+                        ?.asPreRuntime[1].toHex(),
+                ],
+            },
+            ...consensus.rest,
+        ];
+        if (meta.query.randomness) {
+            // TODO: shouldn't modify existing head
+            // reset notFirstBlock so randomness will skip validation
+            head.pushStorageLayer().set(compactHex(meta.query.randomness.notFirstBlock()), StorageValueKind.Deleted);
+        }
+    }
+    const header = meta.registry.createType('Header', {
+        parentHash: head.hash,
+        number: unsafeBlockHeight ?? head.number + 1,
+        stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        digest: {
+            logs: newLogs,
+        },
+    });
+    return header;
+};
+const initNewBlock = async (head, header, inherents, storageLayer, callback) => {
+    const blockNumber = header.number.toNumber();
+    const hash = `0x${Math.round(Math.random() * 100000000)
+        .toString(16)
+        .padEnd(64, '0')}`;
+    const newBlock = new Block(head.chain, blockNumber, hash, head, {
+        header,
+        extrinsics: [],
+        storage: storageLayer ?? head.storage,
+    });
+    {
+        // initialize block
+        const resp = await newBlock.call('Core_initialize_block', [header.toHex()]);
+        newBlock.pushStorageLayer().setAll(resp.storageDiff);
+        callback?.onPhaseApplied?.('initialize', resp);
+    }
+    const layers = [];
+    // apply inherents
+    for (const extrinsic of inherents) {
+        try {
+            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const layer = newBlock.pushStorageLayer();
+            layer.setAll(resp.storageDiff);
+            layers.push(layer);
+            callback?.onPhaseApplied?.(layers.length - 1, resp);
+        }
+        catch (e) {
+            logger.warn('Failed to apply inherents %o %s', e, e);
+            throw new Error('Failed to apply inherents');
+        }
+    }
+    return {
+        block: newBlock,
+        layers: layers,
+    };
+};
+export const buildBlock = async (head, inherents, extrinsics, ump, callbacks, unsafeBlockHeight) => {
+    const registry = await head.registry;
+    const header = await newHeader(head, unsafeBlockHeight);
+    const newBlockNumber = header.number.toNumber();
+    logger.info({
+        number: newBlockNumber,
+        extrinsicsCount: extrinsics.length,
+        umpCount: Object.keys(ump).length,
+    }, `Try building block #${newBlockNumber.toLocaleString()}`);
+    let layer;
+    // apply ump via storage override hack
+    if (Object.keys(ump).length > 0) {
+        const meta = await head.meta;
+        layer = new StorageLayer(head.storage);
+        for (const [paraId, upwardMessages] of Object.entries(ump)) {
+            const upwardMessagesU8a = upwardMessages.map((x) => hexToU8a(x));
+            const messagesCount = upwardMessages.length;
+            const messagesSize = upwardMessagesU8a.map((x) => x.length).reduce((s, i) => s + i, 0);
+            if (meta.query.ump) {
+                const queueSize = meta.registry.createType('(u32, u32)', [messagesCount, messagesSize]);
+                const messages = meta.registry.createType('Vec<Bytes>', upwardMessages);
+                // TODO: make sure we append instead of replace
+                layer.setAll([
+                    [compactHex(meta.query.ump.relayDispatchQueues(paraId)), messages.toHex()],
+                    [compactHex(meta.query.ump.relayDispatchQueueSize(paraId)), queueSize.toHex()],
+                ]);
+            }
+            else if (meta.query.messageQueue) {
+                // TODO: make sure we append instead of replace
+                const origin = { ump: { para: paraId } };
+                let last = 0;
+                let heap = new Uint8Array(0);
+                for (const message of upwardMessagesU8a) {
+                    const payloadLen = message.length;
+                    const header = meta.registry.createType('(u32, bool)', [payloadLen, false]);
+                    last = heap.length;
+                    heap = u8aConcat(heap, header.toU8a(), message);
+                }
+                layer.setAll([
+                    [
+                        compactHex(meta.query.messageQueue.bookStateFor(origin)),
+                        meta.registry
+                            .createType('PalletMessageQueueBookState', {
+                            begin: 0,
+                            end: 1,
+                            count: 1,
+                            readyNeighbours: { prev: origin, next: origin },
+                            messageCount: messagesCount,
+                            size_: messagesSize,
+                        })
+                            .toHex(),
+                    ],
+                    [
+                        compactHex(meta.query.messageQueue.serviceHead(origin)),
+                        meta.registry.createType('PolkadotRuntimeParachainsInclusionAggregateMessageOrigin', origin).toHex(),
+                    ],
+                    [
+                        compactHex(meta.query.messageQueue.pages(origin, 0)),
+                        meta.registry
+                            .createType('PalletMessageQueuePage', {
+                            remaining: messagesCount,
+                            remaining_size: messagesSize,
+                            first_index: 0,
+                            first: 0,
+                            last,
+                            heap: compactAddLength(heap),
+                        })
+                            .toHex(),
+                    ],
+                ]);
+            }
+            else {
+                throw new Error('Unknown ump storage');
+            }
+            logger.trace({ paraId, upwardMessages: truncate(upwardMessages) }, 'Pushed UMP');
+        }
+        if (meta.query.ump) {
+            const needsDispatch = meta.registry.createType('Vec<u32>', Object.keys(ump));
+            layer.set(compactHex(meta.query.ump.needsDispatch()), needsDispatch.toHex());
+        }
+    }
+    const { block: newBlock } = await initNewBlock(head, header, inherents, layer);
+    const pendingExtrinsics = [];
+    const includedExtrinsic = [];
+    // apply extrinsics
+    for (const extrinsic of extrinsics) {
+        try {
+            const resp = await newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const outcome = registry.createType('ApplyExtrinsicResult', resp.result);
+            if (outcome.isErr) {
+                callbacks?.onApplyExtrinsicError?.(extrinsic, outcome.asErr);
+                continue;
+            }
+            newBlock.pushStorageLayer().setAll(resp.storageDiff);
+            includedExtrinsic.push(extrinsic);
+            callbacks?.onPhaseApplied?.(includedExtrinsic.length - 1, resp);
+        }
+        catch (e) {
+            logger.info('Failed to apply extrinsic %o %s', e, e);
+            pendingExtrinsics.push(extrinsic);
+        }
+    }
+    {
+        // finalize block
+        const resp = await newBlock.call('BlockBuilder_finalize_block', []);
+        newBlock.pushStorageLayer().setAll(resp.storageDiff);
+        callbacks?.onPhaseApplied?.('finalize', resp);
+    }
+    const blockData = registry.createType('Block', {
+        header,
+        extrinsics: includedExtrinsic,
+    });
+    const storageDiff = await newBlock.storageDiff();
+    if (logger.level.toLowerCase() === 'trace') {
+        logger.trace(Object.entries(storageDiff).map(([key, value]) => [key, truncate(value)]), 'Final block');
+    }
+    const finalBlock = new Block(head.chain, newBlock.number, blockData.hash.toHex(), head, {
+        header,
+        extrinsics: [...inherents, ...includedExtrinsic],
+        storage: head.storage,
+        storageDiff,
+    });
+    logger.info({
+        number: newBlock.number,
+        hash: finalBlock.hash,
+        extrinsics: truncate(includedExtrinsic),
+        pendingExtrinsicsCount: pendingExtrinsics.length,
+        ump: truncate(ump),
+    }, 'Block built');
+    return [finalBlock, pendingExtrinsics];
+};
+export const dryRunExtrinsic = async (head, inherents, extrinsic) => {
+    const registry = await head.registry;
+    const header = await newHeader(head);
+    const { block: newBlock } = await initNewBlock(head, header, inherents);
+    if (typeof extrinsic !== 'string') {
+        if (!head.chain.mockSignatureHost) {
+            throw new Error('Cannot fake signature because mock signature host is not enabled. Start chain with `mockSignatureHost: true`');
+        }
+        const meta = await head.meta;
+        const call = registry.createType('Call', hexToU8a(extrinsic.call));
+        const generic = registry.createType('GenericExtrinsic', call);
+        const accountRaw = await head.get(compactHex(meta.query.system.account(extrinsic.address)));
+        const account = registry.createType('AccountInfo', hexToU8a(accountRaw));
+        generic.signFake(extrinsic.address, {
+            blockHash: head.hash,
+            genesisHash: head.hash,
+            runtimeVersion: await head.runtimeVersion,
+            nonce: account.nonce,
+        });
+        const mockSignature = new Uint8Array(64);
+        mockSignature.fill(0xcd);
+        mockSignature.set([0xde, 0xad, 0xbe, 0xef]);
+        generic.signature.set(mockSignature);
+        defaultLogger.info({ call: call.toHuman() }, 'dry_run_call');
+        return newBlock.call('BlockBuilder_apply_extrinsic', [generic.toHex()]);
+    }
+    defaultLogger.info({ call: registry.createType('GenericExtrinsic', hexToU8a(extrinsic)).toHuman() }, 'dry_run_extrinsic');
+    return newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+};
+export const dryRunInherents = async (head, inherents) => {
+    const header = await newHeader(head);
+    const { layers } = await initNewBlock(head, header, inherents);
+    const storage = {};
+    for (const layer of layers) {
+        await layer.mergeInto(storage);
+    }
+    return Object.entries(storage);
+};