@acala-network/chopsticks-core 0.8.0-0

package/lib/api.d.ts

@@ -0,0 +1,43 @@
+import { ExtDef } from '@polkadot/types/extrinsic/signedExtensions/types';
+import { HexString } from '@polkadot/util/types';
+import { ProviderInterface } from '@polkadot/rpc-provider/types';
+type ChainProperties = {
+    ss58Format?: number;
+    tokenDecimals?: number[];
+    tokenSymbol?: string[];
+};
+type Header = {
+    parentHash: HexString;
+    number: HexString;
+    stateRoot: HexString;
+    extrinsicsRoot: HexString;
+    digest: {
+        logs: HexString[];
+    };
+};
+type SignedBlock = {
+    block: {
+        header: Header;
+        extrinsics: HexString[];
+    };
+    justifications?: HexString[];
+};
+export declare class Api {
+    #private;
+    readonly signedExtensions: ExtDef;
+    constructor(provider: ProviderInterface, signedExtensions?: ExtDef);
+    disconnect(): Promise<void>;
+    get isReady(): Promise<void> | undefined;
+    get chain(): Promise<string>;
+    get chainProperties(): Promise<ChainProperties>;
+    getSystemName(): Promise<string>;
+    getSystemProperties(): Promise<ChainProperties>;
+    getSystemChain(): Promise<string>;
+    getMetadata(hash?: string): Promise<string>;
+    getBlockHash(blockNumber?: number): Promise<`0x${string}`>;
+    getHeader(hash?: string): Promise<Header>;
+    getBlock(hash?: string): Promise<SignedBlock>;
+    getStorage(key: string, hash?: string): Promise<string>;
+    getKeysPaged(prefix: string, pageSize: number, startKey: string, hash?: string): Promise<string[]>;
+}
+export {};

package/lib/api.js

@@ -0,0 +1,116 @@
+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());
+    });
+};
+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;
+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 || {};
+    }
+    disconnect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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) => {
+                    __classPrivateFieldGet(this, _Api_provider, "f").on('connected', () => {
+                        resolve();
+                    });
+                    __classPrivateFieldGet(this, _Api_provider, "f").connect();
+                }), "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");
+    }
+    getSystemName() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_name', []);
+        });
+    }
+    getSystemProperties() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_properties', []);
+        });
+    }
+    getSystemChain() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('system_chain', []);
+        });
+    }
+    getMetadata(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getMetadata', hash ? [hash] : []);
+        });
+    }
+    getBlockHash(blockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlockHash', Number.isInteger(blockNumber) ? [blockNumber] : []);
+        });
+    }
+    getHeader(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getHeader', hash ? [hash] : []);
+        });
+    }
+    getBlock(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('chain_getBlock', hash ? [hash] : []);
+        });
+    }
+    getStorage(key, hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = [key];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getStorage', params);
+        });
+    }
+    getKeysPaged(prefix, pageSize, startKey, hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const params = [prefix, pageSize, startKey];
+            if (hash)
+                params.push(hash);
+            return __classPrivateFieldGet(this, _Api_provider, "f").send('state_getKeysPaged', params);
+        });
+    }
+}
+_Api_provider = new WeakMap(), _Api_ready = new WeakMap(), _Api_chain = new WeakMap(), _Api_chainProperties = new WeakMap();

package/lib/blockchain/block-builder.d.ts

@@ -0,0 +1,10 @@
+import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
+import { Block, TaskCallResponse } from './block';
+import { HexString } from '@polkadot/util/types';
+export declare const newHeader: (head: Block) => Promise<Header>;
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void) => Promise<[Block, HexString[]]>;
+export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
+    call: HexString;
+    address: string;
+}) => Promise<TaskCallResponse>;
+export declare const dryRunInherents: (head: Block, inherents: HexString[]) => Promise<[HexString, HexString | null][]>;

package/lib/blockchain/block-builder.js

@@ -0,0 +1,290 @@
+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());
+    });
+};
+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: Object.assign(Object.assign({}, digest.asPrimary.toJSON()), { slotNumber }),
+        };
+    }
+    if (digest.isSecondaryPlain) {
+        return {
+            secondaryPlain: Object.assign(Object.assign({}, digest.asSecondaryPlain.toJSON()), { slotNumber }),
+        };
+    }
+    if (digest.isSecondaryVRF) {
+        return {
+            secondaryVRF: Object.assign(Object.assign({}, digest.asSecondaryVRF.toJSON()), { slotNumber }),
+        };
+    }
+    return digest.toJSON();
+};
+export const newHeader = (head) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const meta = yield head.meta;
+    const parentHeader = yield head.header;
+    let newLogs = parentHeader.digest.logs;
+    const consensus = getConsensus(parentHeader);
+    if (consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine.isAura) {
+        const slot = yield getCurrentSlot(head.chain);
+        const newSlot = compactAddLength(meta.registry.createType('Slot', slot + 1).toU8a());
+        newLogs = [{ PreRuntime: [consensus.consensusEngine, newSlot] }, ...consensus.rest];
+    }
+    else if (consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine.isBabe) {
+        const slot = yield 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 (((_a = consensus === null || consensus === void 0 ? void 0 : consensus.consensusEngine) === null || _a === void 0 ? void 0 : _a.toString()) == 'nmbs') {
+        const nmbsKey = stringToHex('nmbs');
+        newLogs = [
+            {
+                // Using previous block author
+                PreRuntime: [
+                    consensus.consensusEngine,
+                    (_b = parentHeader.digest.logs
+                        .find((log) => log.isPreRuntime && log.asPreRuntime[0].toHex() == nmbsKey)) === null || _b === void 0 ? void 0 : _b.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: head.number + 1,
+        stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        digest: {
+            logs: newLogs,
+        },
+    });
+    return header;
+});
+const initNewBlock = (head, header, inherents, storageLayer) => __awaiter(void 0, void 0, void 0, function* () {
+    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 !== null && storageLayer !== void 0 ? storageLayer : head.storage,
+    });
+    {
+        // initialize block
+        const { storageDiff } = yield newBlock.call('Core_initialize_block', [header.toHex()]);
+        newBlock.pushStorageLayer().setAll(storageDiff);
+        logger.trace(truncate(storageDiff), 'Initialize block');
+    }
+    const layers = [];
+    // apply inherents
+    for (const extrinsic of inherents) {
+        try {
+            const { storageDiff } = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const layer = newBlock.pushStorageLayer();
+            layer.setAll(storageDiff);
+            layers.push(layer);
+            logger.trace(truncate(storageDiff), 'Applied inherent');
+        }
+        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 = (head, inherents, extrinsics, ump, onApplyExtrinsicError) => __awaiter(void 0, void 0, void 0, function* () {
+    const registry = yield head.registry;
+    const header = yield newHeader(head);
+    logger.info({
+        number: head.number + 1,
+        extrinsicsCount: extrinsics.length,
+        umpCount: Object.keys(ump).length,
+    }, `Try building block #${(head.number + 1).toLocaleString()}`);
+    let layer;
+    // apply ump via storage override hack
+    if (Object.keys(ump).length > 0) {
+        const meta = yield 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 } = yield initNewBlock(head, header, inherents, layer);
+    const pendingExtrinsics = [];
+    const includedExtrinsic = [];
+    // apply extrinsics
+    for (const extrinsic of extrinsics) {
+        try {
+            const { result, storageDiff } = yield newBlock.call('BlockBuilder_apply_extrinsic', [extrinsic]);
+            const outcome = registry.createType('ApplyExtrinsicResult', result);
+            if (outcome.isErr) {
+                onApplyExtrinsicError(extrinsic, outcome.asErr);
+                continue;
+            }
+            newBlock.pushStorageLayer().setAll(storageDiff);
+            logger.trace(truncate(storageDiff), 'Applied extrinsic');
+            includedExtrinsic.push(extrinsic);
+        }
+        catch (e) {
+            logger.info('Failed to apply extrinsic %o %s', e, e);
+            pendingExtrinsics.push(extrinsic);
+        }
+    }
+    {
+        // finalize block
+        const { storageDiff } = yield newBlock.call('BlockBuilder_finalize_block', []);
+        newBlock.pushStorageLayer().setAll(storageDiff);
+        logger.trace(truncate(storageDiff), 'Finalize block');
+    }
+    const blockData = registry.createType('Block', {
+        header,
+        extrinsics: includedExtrinsic,
+    });
+    const storageDiff = yield newBlock.storageDiff();
+    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 = (head, inherents, extrinsic) => __awaiter(void 0, void 0, void 0, function* () {
+    const registry = yield head.registry;
+    const header = yield newHeader(head);
+    const { block: newBlock } = yield 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 = yield head.meta;
+        const call = registry.createType('Call', hexToU8a(extrinsic.call));
+        const generic = registry.createType('GenericExtrinsic', call);
+        const accountRaw = yield 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: yield 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 = (head, inherents) => __awaiter(void 0, void 0, void 0, function* () {
+    const header = yield newHeader(head);
+    const { layers } = yield initNewBlock(head, header, inherents);
+    const storage = {};
+    for (const layer of layers) {
+        yield layer.mergeInto(storage);
+    }
+    return Object.entries(storage);
+});

package/lib/blockchain/block.d.ts

@@ -0,0 +1,45 @@
+import { Header } from '@polkadot/types/interfaces';
+import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
+import { TypeRegistry } from '@polkadot/types';
+import type { HexString } from '@polkadot/util/types';
+import { Blockchain } from '.';
+import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
+import type { RuntimeVersion } from '../executor';
+export type TaskCallResponse = {
+    result: HexString;
+    storageDiff: [HexString, HexString | null][];
+    offchainStorageDiff: [HexString, HexString | null][];
+    runtimeLogs: string[];
+};
+export declare class Block {
+    #private;
+    readonly number: number;
+    readonly hash: HexString;
+    constructor(chain: Blockchain, number: number, hash: HexString, parentBlock?: Block, block?: {
+        header: Header;
+        extrinsics: HexString[];
+        storage?: StorageLayerProvider;
+        storageDiff?: Record<string, StorageValue | null>;
+    });
+    get chain(): Blockchain;
+    get header(): Header | Promise<Header>;
+    get extrinsics(): HexString[] | Promise<HexString[]>;
+    get parentBlock(): undefined | Block | Promise<Block | undefined>;
+    get storage(): StorageLayerProvider;
+    get(key: string): Promise<string | undefined>;
+    getKeysPaged(options: {
+        prefix?: string;
+        startKey?: string;
+        pageSize: number;
+    }): Promise<string[]>;
+    pushStorageLayer(): StorageLayer;
+    popStorageLayer(): void;
+    storageDiff(): Promise<Record<HexString, HexString | null>>;
+    get wasm(): Promise<`0x${string}`>;
+    setWasm(wasm: HexString): void;
+    get registry(): Promise<TypeRegistry>;
+    get runtimeVersion(): Promise<RuntimeVersion>;
+    get metadata(): Promise<HexString>;
+    get meta(): Promise<DecoratedMeta>;
+    call(method: string, args: HexString[]): Promise<TaskCallResponse>;
+}