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

package/dist/esm/blockchain/block.js

@@ -0,0 +1,277 @@
+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, printRuntimeLogs } from '../utils';
+import { getRuntimeVersion, runTask, taskHandler } from '../wasm-executor';
+/**
+ * Block class.
+ *
+ * @example Instantiate a block
+ *
+ * ```ts
+ * const block = new Block(chain, number, hash)
+ * ```
+ *
+ * @example Get storage
+ *
+ * ```ts
+ * const block = await chain.getBlock('0x...')
+ * block.storage()
+ * ```
+ */
+export class Block {
+    constructor(chain, number, hash, parentBlock, block) {
+        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 ? new WeakRef(parentBlock) : undefined, "f");
+        __classPrivateFieldSet(this, _Block_header, block?.header, "f");
+        __classPrivateFieldSet(this, _Block_extrinsics, block?.extrinsics, "f");
+        __classPrivateFieldSet(this, _Block_baseStorage, block?.storage ?? new RemoteStorageLayer(chain.api, hash, chain.db), "f");
+        __classPrivateFieldSet(this, _Block_storages, [], "f");
+        __classPrivateFieldSet(this, _Block_runtimeVersion, parentBlock?.runtimeVersion, "f");
+        __classPrivateFieldSet(this, _Block_metadata, parentBlock?.metadata, "f");
+        __classPrivateFieldSet(this, _Block_registry, parentBlock?.registry, "f");
+        __classPrivateFieldSet(this, _Block_meta, parentBlock?.meta, "f");
+        const storageDiff = block?.storageDiff;
+        if (storageDiff) {
+            // if code doesn't change then keep parent block's meta
+            // otherwise reset meta
+            if (storageDiff[stringToHex(':code')]) {
+                __classPrivateFieldSet(this, _Block_runtimeVersion, undefined, "f");
+                __classPrivateFieldSet(this, _Block_metadata, undefined, "f");
+                __classPrivateFieldSet(this, _Block_registry, undefined, "f");
+                __classPrivateFieldSet(this, _Block_meta, undefined, "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) => {
+                if (!b) {
+                    throw new Error(`Block ${this.hash} not found`);
+                }
+                return b.block.extrinsics;
+            }), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_extrinsics, "f");
+    }
+    get parentBlock() {
+        if (this.number === 0) {
+            return Promise.resolve(undefined);
+        }
+        const getBlock = async (header) => {
+            const _header = await header;
+            const block = await __classPrivateFieldGet(this, _Block_chain, "f").getBlock(_header.parentHash.toHex());
+            if (block)
+                __classPrivateFieldSet(this, _Block_parentBlock, new WeakRef(block), "f");
+            return block;
+        };
+        if (__classPrivateFieldGet(this, _Block_parentBlock, "f") instanceof WeakRef) {
+            const block = __classPrivateFieldGet(this, _Block_parentBlock, "f").deref();
+            if (block)
+                return Promise.resolve(block);
+            __classPrivateFieldSet(this, _Block_parentBlock, getBlock(this.header), "f");
+        }
+        else if (!__classPrivateFieldGet(this, _Block_parentBlock, "f")) {
+            __classPrivateFieldSet(this, _Block_parentBlock, getBlock(this.header), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_parentBlock, "f");
+    }
+    /**
+     * Get the block storage.
+     */
+    get storage() {
+        return __classPrivateFieldGet(this, _Block_storages, "f")[__classPrivateFieldGet(this, _Block_storages, "f").length - 1] ?? __classPrivateFieldGet(this, _Block_baseStorage, "f");
+    }
+    /**
+     * Get the block storage by key.
+     */
+    async get(key) {
+        const val = await this.storage.get(key, true);
+        switch (val) {
+            case StorageValueKind.Deleted:
+                return undefined;
+            default:
+                return val;
+        }
+    }
+    async read(type, query, ...args) {
+        const key = compactHex(query(...args));
+        const value = await this.get(key);
+        if (!value) {
+            return undefined;
+        }
+        const registry = await this.registry;
+        return registry.createType(type, hexToU8a(value));
+    }
+    /**
+     * Get paged storage keys.
+     */
+    async getKeysPaged(options) {
+        const layer = new StorageLayer(this.storage);
+        await layer.fold();
+        const prefix = options.prefix ?? '0x';
+        const startKey = options.startKey ?? '0x';
+        const pageSize = options.pageSize;
+        return layer.getKeysPaged(prefix, pageSize, startKey);
+    }
+    /**
+     * Push a layer to the storage stack.
+     */
+    pushStorageLayer() {
+        const layer = new StorageLayer(this.storage);
+        __classPrivateFieldGet(this, _Block_storages, "f").push(layer);
+        return layer;
+    }
+    /**
+     * Pop a layer from the storage stack.
+     */
+    popStorageLayer() {
+        __classPrivateFieldGet(this, _Block_storages, "f").pop();
+    }
+    /**
+     * Get storage diff.
+     */
+    async storageDiff() {
+        const storage = {};
+        for (const layer of __classPrivateFieldGet(this, _Block_storages, "f")) {
+            await layer.mergeInto(storage);
+        }
+        return storage;
+    }
+    /**
+     * Get the wasm string.
+     */
+    get wasm() {
+        if (!__classPrivateFieldGet(this, _Block_wasm, "f")) {
+            __classPrivateFieldSet(this, _Block_wasm, (async () => {
+                const wasmKey = stringToHex(':code');
+                const wasm = await this.get(wasmKey);
+                if (!wasm) {
+                    throw new Error('No wasm found');
+                }
+                return wasm;
+            })(), "f");
+        }
+        return __classPrivateFieldGet(this, _Block_wasm, "f");
+    }
+    /**
+     * Set the runtime wasm.
+     */
+    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 the type registry.
+     * @see https://polkadot.js.org/docs/api/start/types.create#why-create-types
+     */
+    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 a runtime method.
+     */
+    async call(method, args) {
+        const wasm = await this.wasm;
+        const response = await 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 ('Call' in response) {
+            printRuntimeLogs(response.Call.runtimeLogs);
+            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/dist/esm/blockchain/head-state.js

@@ -0,0 +1,79 @@
+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];
+    }
+    async subscribeStorage(keys, cb) {
+        const id = randomId();
+        __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [keys, cb];
+        for (const key of keys) {
+            __classPrivateFieldGet(this, _HeadState_oldValues, "f")[key] = await __classPrivateFieldGet(this, _HeadState_head, "f").get(key).then((val) => val || null);
+        }
+        return id;
+    }
+    unsubscribeStorage(id) {
+        delete __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id];
+    }
+    async subscrubeRuntimeVersion(cb) {
+        const id = randomId();
+        const codeKey = stringToHex(':code');
+        __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id] = [[codeKey], cb];
+        __classPrivateFieldGet(this, _HeadState_oldValues, "f")[codeKey] = await __classPrivateFieldGet(this, _HeadState_head, "f").get(codeKey).then((val) => val || null);
+        return id;
+    }
+    unsubscribeRuntimeVersion(id) {
+        delete __classPrivateFieldGet(this, _HeadState_storageListeners, "f")[id];
+    }
+    async setHead(head) {
+        __classPrivateFieldSet(this, _HeadState_head, head, "f");
+        for (const cb of Object.values(__classPrivateFieldGet(this, _HeadState_headListeners, "f"))) {
+            try {
+                await cb(head);
+            }
+            catch (error) {
+                logger.error(error, 'setHead head callback error');
+            }
+        }
+        const diff = await __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 {
+                    await 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();