@acala-network/chopsticks-core 0.8.0-0

package/lib/blockchain/block.js

@@ -0,0 +1,221 @@
+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 _Block_chain, _Block_header, _Block_parentBlock, _Block_extrinsics, _Block_wasm, _Block_runtimeVersion, _Block_metadata, _Block_registry, _Block_meta, _Block_baseStorage, _Block_storages;
+import { Metadata, TypeRegistry } from '@polkadot/types';
+import { expandMetadata } from '@polkadot/types/metadata';
+import { getSpecExtensions, getSpecHasher, getSpecTypes } from '@polkadot/types-known/util';
+import { hexToU8a, objectSpread, stringToHex } from '@polkadot/util';
+import { RemoteStorageLayer, StorageLayer, StorageValueKind } from './storage-layer';
+import { compactHex } from '../utils';
+import { defaultLogger } from '../logger';
+import { getRuntimeVersion, runTask, taskHandler } from '../executor';
+export class Block {
+    constructor(chain, number, hash, parentBlock, block) {
+        var _a;
+        this.number = number;
+        this.hash = hash;
+        _Block_chain.set(this, void 0);
+        _Block_header.set(this, void 0);
+        _Block_parentBlock.set(this, void 0);
+        _Block_extrinsics.set(this, void 0);
+        _Block_wasm.set(this, void 0);
+        _Block_runtimeVersion.set(this, void 0);
+        _Block_metadata.set(this, void 0);
+        _Block_registry.set(this, void 0);
+        _Block_meta.set(this, void 0);
+        _Block_baseStorage.set(this, void 0);
+        _Block_storages.set(this, void 0);
+        __classPrivateFieldSet(this, _Block_chain, chain, "f");
+        __classPrivateFieldSet(this, _Block_parentBlock, parentBlock, "f");
+        __classPrivateFieldSet(this, _Block_header, block === null || block === void 0 ? void 0 : block.header, "f");
+        __classPrivateFieldSet(this, _Block_extrinsics, block === null || block === void 0 ? void 0 : block.extrinsics, "f");
+        __classPrivateFieldSet(this, _Block_baseStorage, (_a = block === null || block === void 0 ? void 0 : block.storage) !== null && _a !== void 0 ? _a : new RemoteStorageLayer(chain.api, hash, chain.db), "f");
+        __classPrivateFieldSet(this, _Block_storages, [], "f");
+        const storageDiff = block === null || block === void 0 ? void 0 : block.storageDiff;
+        if (storageDiff) {
+            // if code doesn't change then reuse parent block's meta
+            if (!(storageDiff === null || storageDiff === void 0 ? void 0 : storageDiff[stringToHex(':code')])) {
+                __classPrivateFieldSet(this, _Block_runtimeVersion, parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.runtimeVersion, "f");
+                __classPrivateFieldSet(this, _Block_metadata, parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.metadata, "f");
+                __classPrivateFieldSet(this, _Block_registry, parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.registry, "f");
+                __classPrivateFieldSet(this, _Block_meta, parentBlock === null || parentBlock === void 0 ? void 0 : parentBlock.meta, "f");
+            }
+            this.pushStorageLayer().setAll(storageDiff);
+        }
+    }
+    get chain() {
+        return __classPrivateFieldGet(this, _Block_chain, "f");
+    }
+    get header() {
+        if (!__classPrivateFieldGet(this, _Block_header, "f")) {
+            __classPrivateFieldSet(this, _Block_header, Promise.all([this.registry, __classPrivateFieldGet(this, _Block_chain, "f").api.getHeader(this.hash)]).then(([registry, header]) => registry.createType('Header', header)), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_header, "f");
+    }
+    get extrinsics() {
+        if (!__classPrivateFieldGet(this, _Block_extrinsics, "f")) {
+            __classPrivateFieldSet(this, _Block_extrinsics, __classPrivateFieldGet(this, _Block_chain, "f").api.getBlock(this.hash).then((b) => b.block.extrinsics), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_extrinsics, "f");
+    }
+    get parentBlock() {
+        if (this.number === 0) {
+            return undefined;
+        }
+        if (!__classPrivateFieldGet(this, _Block_parentBlock, "f")) {
+            __classPrivateFieldSet(this, _Block_parentBlock, Promise.resolve(this.header).then((h) => __classPrivateFieldGet(this, _Block_chain, "f").getBlock(h.parentHash.toHex())), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_parentBlock, "f");
+    }
+    get storage() {
+        var _a;
+        return (_a = __classPrivateFieldGet(this, _Block_storages, "f")[__classPrivateFieldGet(this, _Block_storages, "f").length - 1]) !== null && _a !== void 0 ? _a : __classPrivateFieldGet(this, _Block_baseStorage, "f");
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const val = yield this.storage.get(key, true);
+            switch (val) {
+                case StorageValueKind.Deleted:
+                    return undefined;
+                default:
+                    return val;
+            }
+        });
+    }
+    getKeysPaged(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            const layer = new StorageLayer(this.storage);
+            yield layer.fold();
+            const prefix = (_a = options.prefix) !== null && _a !== void 0 ? _a : '0x';
+            const startKey = (_b = options.startKey) !== null && _b !== void 0 ? _b : prefix;
+            const pageSize = options.pageSize;
+            return layer.getKeysPaged(prefix, pageSize, startKey);
+        });
+    }
+    pushStorageLayer() {
+        const layer = new StorageLayer(this.storage);
+        __classPrivateFieldGet(this, _Block_storages, "f").push(layer);
+        return layer;
+    }
+    popStorageLayer() {
+        __classPrivateFieldGet(this, _Block_storages, "f").pop();
+    }
+    storageDiff() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const storage = {};
+            for (const layer of __classPrivateFieldGet(this, _Block_storages, "f")) {
+                yield layer.mergeInto(storage);
+            }
+            return storage;
+        });
+    }
+    get wasm() {
+        if (!__classPrivateFieldGet(this, _Block_wasm, "f")) {
+            __classPrivateFieldSet(this, _Block_wasm, (() => __awaiter(this, void 0, void 0, function* () {
+                const wasmKey = stringToHex(':code');
+                const wasm = yield this.get(wasmKey);
+                if (!wasm) {
+                    throw new Error('No wasm found');
+                }
+                return wasm;
+            }))(), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_wasm, "f");
+    }
+    setWasm(wasm) {
+        const wasmKey = stringToHex(':code');
+        this.pushStorageLayer().set(wasmKey, wasm);
+        __classPrivateFieldSet(this, _Block_wasm, Promise.resolve(wasm), "f");
+        __classPrivateFieldSet(this, _Block_runtimeVersion, undefined, "f");
+        __classPrivateFieldSet(this, _Block_registry, undefined, "f");
+        __classPrivateFieldSet(this, _Block_meta, undefined, "f");
+        __classPrivateFieldSet(this, _Block_metadata, undefined, "f");
+    }
+    get registry() {
+        if (!__classPrivateFieldGet(this, _Block_registry, "f")) {
+            __classPrivateFieldSet(this, _Block_registry, Promise.all([
+                this.metadata,
+                __classPrivateFieldGet(this, _Block_chain, "f").api.chainProperties,
+                __classPrivateFieldGet(this, _Block_chain, "f").api.chain,
+                this.runtimeVersion,
+            ]).then(([data, properties, chain, version]) => {
+                const registry = new TypeRegistry(this.hash);
+                registry.setKnownTypes(this.chain.registeredTypes);
+                registry.setChainProperties(registry.createType('ChainProperties', properties));
+                registry.register(getSpecTypes(registry, chain, version.specName, version.specVersion));
+                registry.setHasher(getSpecHasher(registry, chain, version.specName));
+                registry.setMetadata(new Metadata(registry, data), undefined, objectSpread({}, getSpecExtensions(registry, chain, version.specName), __classPrivateFieldGet(this, _Block_chain, "f").api.signedExtensions));
+                return registry;
+            }), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_registry, "f");
+    }
+    get runtimeVersion() {
+        if (!__classPrivateFieldGet(this, _Block_runtimeVersion, "f")) {
+            __classPrivateFieldSet(this, _Block_runtimeVersion, this.wasm.then(getRuntimeVersion), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_runtimeVersion, "f");
+    }
+    get metadata() {
+        if (!__classPrivateFieldGet(this, _Block_metadata, "f")) {
+            __classPrivateFieldSet(this, _Block_metadata, this.call('Metadata_metadata', []).then((resp) => compactHex(hexToU8a(resp.result))), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_metadata, "f");
+    }
+    get meta() {
+        if (!__classPrivateFieldGet(this, _Block_meta, "f")) {
+            __classPrivateFieldSet(this, _Block_meta, Promise.all([this.registry, this.metadata]).then(([registry, metadataStr]) => {
+                const metadata = new Metadata(registry, metadataStr);
+                return expandMetadata(registry, metadata);
+            }), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_meta, "f");
+    }
+    call(method, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const wasm = yield this.wasm;
+            const response = yield runTask({
+                wasm,
+                calls: [[method, args]],
+                mockSignatureHost: __classPrivateFieldGet(this, _Block_chain, "f").mockSignatureHost,
+                allowUnresolvedImports: __classPrivateFieldGet(this, _Block_chain, "f").allowUnresolvedImports,
+                runtimeLogLevel: __classPrivateFieldGet(this, _Block_chain, "f").runtimeLogLevel,
+            }, taskHandler(this));
+            if (response.Call) {
+                for (const log of response.Call.runtimeLogs) {
+                    defaultLogger.info(`RuntimeLogs:\n${log}`);
+                }
+                if (this.chain.offchainWorker) {
+                    // apply offchain storage
+                    for (const [key, value] of response.Call.offchainStorageDiff) {
+                        this.chain.offchainWorker.set(key, value);
+                    }
+                }
+                return response.Call;
+            }
+            if (response.Error)
+                throw Error(response.Error);
+            throw Error('Unexpected response');
+        });
+    }
+}
+_Block_chain = new WeakMap(), _Block_header = new WeakMap(), _Block_parentBlock = new WeakMap(), _Block_extrinsics = new WeakMap(), _Block_wasm = new WeakMap(), _Block_runtimeVersion = new WeakMap(), _Block_metadata = new WeakMap(), _Block_registry = new WeakMap(), _Block_meta = new WeakMap(), _Block_baseStorage = new WeakMap(), _Block_storages = new WeakMap();

package/lib/blockchain/head-state.d.ts

@@ -0,0 +1,15 @@
+import { Block } from './block';
+type Callback = (block: Block, pairs: [string, string][]) => void | Promise<void>;
+export declare const randomId: () => string;
+export declare class HeadState {
+    #private;
+    constructor(head: Block);
+    subscribeHead(cb: (block: Block) => void): string;
+    unsubscribeHead(id: string): void;
+    subscribeStorage(keys: string[], cb: Callback): Promise<string>;
+    unsubscribeStorage(id: string): void;
+    subscrubeRuntimeVersion(cb: (block: Block) => void): Promise<string>;
+    unsubscribeRuntimeVersion(id: string): void;
+    setHead(head: Block): Promise<void>;
+}
+export {};

package/lib/blockchain/head-state.js

@@ -0,0 +1,94 @@
+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 _HeadState_headListeners, _HeadState_storageListeners, _HeadState_oldValues, _HeadState_head;
+import { stringToHex } from '@polkadot/util';
+import { defaultLogger } from '../logger';
+export const randomId = () => Math.random().toString(36).substring(2);
+const logger = defaultLogger.child({ name: 'head-state' });
+export class HeadState {
+    constructor(head) {
+        _HeadState_headListeners.set(this, {});
+        _HeadState_storageListeners.set(this, {});
+        _HeadState_oldValues.set(this, {});
+        _HeadState_head.set(this, void 0);
+        __classPrivateFieldSet(this, _HeadState_head, head, "f");
+    }
+    subscribeHead(cb) {
+        const id = randomId();
+        __classPrivateFieldGet(this, _HeadState_headListeners, "f")[id] = cb;
+        return id;
+    }
+    unsubscribeHead(id) {
+        delete __classPrivateFieldGet(this, _HeadState_headListeners, "f")[id];
+    }
+    subscribeStorage(keys, cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = randomId();
+            __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [keys, cb];
+            for (const key of keys) {
+                __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(key);
+            }
+            return id;
+        });
+    }
+    unsubscribeStorage(id) {
+        delete __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id];
+    }
+    subscrubeRuntimeVersion(cb) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const id = randomId();
+            const codeKey = stringToHex(':code');
+            __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [[codeKey], cb];
+            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = yield __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey);
+            return id;
+        });
+    }
+    unsubscribeRuntimeVersion(id) {
+        delete __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id];
+    }
+    setHead(head) {
+        return __awaiter(this, void 0, void 0, function* () {
+            __classPrivateFieldSet(this, _HeadState_head, head, "f");
+            for (const cb of Object.values(__classPrivateFieldGet(this, _HeadState_headListeners, "f"))) {
+                try {
+                    yield cb(head);
+                }
+                catch (error) {
+                    logger.error(error, 'setHead head callback error');
+                }
+            }
+            const diff = yield __classPrivateFieldGet(this, _HeadState_head, "f").storageDiff();
+            for (const [keys, cb] of Object.values(__classPrivateFieldGet(this, _HeadState_storageListeners, "f"))) {
+                const changed = keys.filter((key) => diff[key]).map((key) => [key, diff[key]]);
+                if (changed.length > 0) {
+                    try {
+                        yield cb(head, changed);
+                    }
+                    catch (error) {
+                        logger.error(error, 'setHead storage diff callback error');
+                    }
+                }
+            }
+            Object.assign(__classPrivateFieldGet(this, _HeadState_oldValues, "f"), diff);
+        });
+    }
+}
+_HeadState_headListeners = new WeakMap(), _HeadState_storageListeners = new WeakMap(), _HeadState_oldValues = new WeakMap(), _HeadState_head = new WeakMap();

package/lib/blockchain/index.d.ts

@@ -0,0 +1,73 @@
+import { ApplyExtrinsicResult } from '@polkadot/types/interfaces';
+import { DataSource } from 'typeorm';
+import { HexString } from '@polkadot/util/types';
+import { RegisteredTypes } from '@polkadot/types/types';
+import type { TransactionValidity } from '@polkadot/types/interfaces/txqueue';
+import { Api } from '../api';
+import { Block } from './block';
+import { BuildBlockMode, BuildBlockParams, DownwardMessage, HorizontalMessage, TxPool } from './txpool';
+import { HeadState } from './head-state';
+import { InherentProvider } from './inherent';
+import { OffchainWorker } from '../offchain';
+export interface Options {
+    api: Api;
+    buildBlockMode?: BuildBlockMode;
+    inherentProvider: InherentProvider;
+    db?: DataSource;
+    header: {
+        number: number;
+        hash: HexString;
+    };
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
+    runtimeLogLevel?: number;
+    registeredTypes: RegisteredTypes;
+    offchainWorker?: boolean;
+    maxMemoryBlockCount?: number;
+}
+export declare class Blockchain {
+    #private;
+    readonly uid: string;
+    readonly api: Api;
+    readonly db: DataSource | undefined;
+    readonly mockSignatureHost: boolean;
+    readonly allowUnresolvedImports: boolean;
+    readonly runtimeLogLevel: number;
+    readonly registeredTypes: RegisteredTypes;
+    readonly headState: HeadState;
+    readonly offchainWorker: OffchainWorker | undefined;
+    constructor({ api, buildBlockMode, inherentProvider, db, header, mockSignatureHost, allowUnresolvedImports, runtimeLogLevel, registeredTypes, offchainWorker, maxMemoryBlockCount, }: Options);
+    get head(): Block;
+    get txPool(): TxPool;
+    saveBlockToDB(block: Block): Promise<void>;
+    /**
+     * Try to load block from db and register it
+     * If pass in number, get block by number, else get block by hash
+     */
+    loadBlockFromDB(key: number | HexString): Promise<Block | undefined>;
+    getBlockAt(number?: number): Promise<Block | undefined>;
+    getBlock(hash?: HexString): Promise<Block | undefined>;
+    blocksInMemory(): Block[];
+    unregisterBlock(block: Block): Promise<void>;
+    onNewBlock(block: Block): Promise<void>;
+    setHead(block: Block): Promise<void>;
+    submitExtrinsic(extrinsic: HexString): Promise<HexString>;
+    validateExtrinsic(extrinsic: HexString, source?: '0x00' | '0x01' | '0x02' /** External */): Promise<TransactionValidity>;
+    submitUpwardMessages(id: number, ump: HexString[]): void;
+    submitDownwardMessages(dmp: DownwardMessage[]): void;
+    submitHorizontalMessages(id: number, hrmp: HorizontalMessage[]): void;
+    newBlock(params?: Partial<BuildBlockParams>): Promise<Block>;
+    newBlockWithParams(params: BuildBlockParams): Promise<Block>;
+    upcomingBlocks(): Promise<number>;
+    dryRunExtrinsic(extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString): Promise<{
+        outcome: ApplyExtrinsicResult;
+        storageDiff: [HexString, HexString | null][];
+    }>;
+    dryRunHrmp(hrmp: Record<number, HorizontalMessage[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    dryRunDmp(dmp: DownwardMessage[], at?: HexString): Promise<[HexString, HexString | null][]>;
+    dryRunUmp(ump: Record<number, HexString[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
+    getInherents(): Promise<HexString[]>;
+}