@acala-network/chopsticks-core 0.8.0-3 → 0.8.0-5

package/lib/api.d.ts

@@ -33,11 +33,10 @@ export declare class Api {
     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>;
+    getBlockHash(blockNumber?: number): Promise<`0x${string}` | null>;
+    getHeader(hash?: string): Promise<Header | null>;
+    getBlock(hash?: string): Promise<SignedBlock | null>;
+    getStorage(key: string, hash?: string): Promise<string | null>;
     getKeysPaged(prefix: string, pageSize: number, startKey: string, hash?: string): Promise<string[]>;
 }
 export {};

package/lib/api.js

@@ -79,11 +79,6 @@ class Api {
             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] : []);

package/lib/blockchain/block.js

@@ -75,7 +75,12 @@ class Block {
     }
     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");
+            __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");
     }

package/lib/blockchain/index.d.ts

@@ -70,4 +70,5 @@ export declare class Blockchain {
     dryRunDmp(dmp: DownwardMessage[], at?: HexString): Promise<[HexString, HexString | null][]>;
     dryRunUmp(ump: Record<number, HexString[]>, at?: HexString): Promise<[HexString, HexString | null][]>;
     getInherents(): Promise<HexString[]>;
+    close(): Promise<void>;
 }

package/lib/blockchain/index.js

@@ -91,14 +91,16 @@ class Blockchain {
      * If pass in number, get block by number, else get block by hash
      */
     loadBlockFromDB(key) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
             if (this.db) {
                 const blockData = yield this.db
                     .getRepository(entities_1.BlockEntity)
                     .findOne({ where: { [typeof key === 'number' ? 'number' : 'hash']: key } });
                 if (blockData) {
-                    const { hash, number, header, extrinsics, parentHash, storageDiff } = blockData;
+                    const { hash, number, header, extrinsics, parentHash } = blockData;
                     const parentBlock = parentHash ? __classPrivateFieldGet(this, _Blockchain_blocksByHash, "f")[parentHash] : undefined;
+                    const storageDiff = (_a = blockData.storageDiff) !== null && _a !== void 0 ? _a : undefined;
                     const block = new block_1.Block(this, number, hash, parentBlock, { header, extrinsics, storageDiff });
                     __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
                     return block;
@@ -121,6 +123,9 @@ class Blockchain {
                     return blockFromDB;
                 }
                 const hash = yield this.api.getBlockHash(number);
+                if (!hash) {
+                    return undefined;
+                }
                 const block = new block_1.Block(this, number, hash);
                 __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
             }
@@ -144,6 +149,9 @@ class Blockchain {
                             const blockFromDB = yield this.loadBlockFromDB(hash);
                             if (!blockFromDB) {
                                 const header = yield this.api.getHeader(hash);
+                                if (!header) {
+                                    throw new Error(`Block ${hash} not found`);
+                                }
                                 const block = new block_1.Block(this, Number(header.number), hash);
                                 __classPrivateFieldGet(this, _Blockchain_instances, "m", _Blockchain_registerBlock).call(this, block);
                             }
@@ -342,6 +350,12 @@ class Blockchain {
             return inherents;
         });
     }
+    close() {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            yield ((_a = this.db) === null || _a === void 0 ? void 0 : _a.destroy());
+        });
+    }
 }
 exports.Blockchain = Blockchain;
 _Blockchain_txpool = new WeakMap(), _Blockchain_inherentProvider = new WeakMap(), _Blockchain_head = new WeakMap(), _Blockchain_blocksByNumber = new WeakMap(), _Blockchain_blocksByHash = new WeakMap(), _Blockchain_loadingBlocks = new WeakMap(), _Blockchain_maxMemoryBlockCount = new WeakMap(), _Blockchain_instances = new WeakSet(), _Blockchain_registerBlock = function _Blockchain_registerBlock(block) {

package/lib/blockchain/storage-layer.js

@@ -47,19 +47,19 @@ class RemoteStorageLayer {
         __classPrivateFieldSet(this, _RemoteStorageLayer_db, db, "f");
     }
     get(key) {
-        var _a;
+        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             const keyValuePair = (_a = __classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")) === null || _a === void 0 ? void 0 : _a.getRepository(entities_1.KeyValuePair);
             if (__classPrivateFieldGet(this, _RemoteStorageLayer_db, "f")) {
                 const res = yield (keyValuePair === null || keyValuePair === void 0 ? void 0 : keyValuePair.findOne({ where: { key, blockHash: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f") } }));
                 if (res) {
-                    return res.value;
+                    return (_b = res.value) !== null && _b !== void 0 ? _b : undefined;
                 }
             }
             logger.trace({ at: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), key }, 'RemoteStorageLayer get');
             const data = yield __classPrivateFieldGet(this, _RemoteStorageLayer_api, "f").getStorage(key, __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"));
             keyValuePair === null || keyValuePair === void 0 ? void 0 : keyValuePair.upsert({ key, blockHash: __classPrivateFieldGet(this, _RemoteStorageLayer_at, "f"), value: data }, ['key', 'blockHash']);
-            return data;
+            return data !== null && data !== void 0 ? data : undefined;
         });
     }
     foldInto(_into) {

package/lib/db/entities.d.ts

@@ -4,13 +4,13 @@ import { HexString } from '@polkadot/util/types';
 export declare const KeyValuePair: EntitySchema<{
     blockHash: string;
     key: string;
-    value?: string | undefined;
+    value: string | null;
 }>;
 export declare const BlockEntity: EntitySchema<{
     hash: HexString;
     number: number;
     header: Header;
-    parentHash?: `0x${string}` | undefined;
+    parentHash: HexString | null;
     extrinsics: HexString[];
-    storageDiff?: Record<`0x${string}`, `0x${string}` | null> | undefined;
+    storageDiff: Record<HexString, HexString | null> | null;
 }>;

package/lib/genesis-provider.js

@@ -49,7 +49,6 @@ var _a, _GenesisProvider_isConnected, _GenesisProvider_eventemitter, _GenesisPro
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenesisProvider = void 0;
 const eventemitter3_1 = require("eventemitter3");
-const util_1 = require("@polkadot/util");
 const axios_1 = __importDefault(require("axios"));
 const schema_1 = require("./schema");
 const executor_1 = require("./executor");
@@ -105,16 +104,6 @@ class GenesisProvider {
                     return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").id;
                 case 'system_name':
                     return __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").name;
-                case 'state_getMetadata': {
-                    const code = __classPrivateFieldGet(this, _GenesisProvider_genesis, "f").genesis.raw.top[(0, util_1.stringToHex)(':code')];
-                    return (0, executor_1.runTask)({
-                        wasm: code,
-                        calls: [['Metadata_metadata', []]],
-                        mockSignatureHost: false,
-                        allowUnresolvedImports: true,
-                        runtimeLogLevel: 0,
-                    }, this._jsCallback);
-                }
                 case 'chain_getHeader':
                     return this.getHeader();
                 case 'chain_getBlock':

package/lib/setup.js

@@ -35,13 +35,24 @@ const setup = (options) => __awaiter(void 0, void 0, void 0, function* () {
     yield api.isReady;
     let blockHash;
     if (options.block == null) {
-        blockHash = yield api.getBlockHash();
+        blockHash = yield api.getBlockHash().then((hash) => {
+            if (!hash) {
+                // should not happen, but just in case
+                throw new Error('Cannot find block hash');
+            }
+            return hash;
+        });
     }
     else if (typeof options.block === 'string' && options.block.startsWith('0x')) {
         blockHash = options.block;
     }
     else if (Number.isInteger(+options.block)) {
-        blockHash = yield api.getBlockHash(Number(options.block));
+        blockHash = yield api.getBlockHash(Number(options.block)).then((hash) => {
+            if (!hash) {
+                throw new Error(`Cannot find block hash for ${options.block}`);
+            }
+            return hash;
+        });
     }
     else {
         throw new Error(`Invalid block number or hash: ${options.block}`);
@@ -52,6 +63,9 @@ const setup = (options) => __awaiter(void 0, void 0, void 0, function* () {
         db = yield (0, db_1.openDb)(options.db);
     }
     const header = yield api.getHeader(blockHash);
+    if (!header) {
+        throw new Error(`Cannot find header for ${blockHash}`);
+    }
     const inherents = new inherent_1.InherentProviders(new inherent_1.SetTimestamp(), [
         new inherent_1.SetValidationData(),
         new inherent_1.ParaInherentEnter(),

package/lib/utils/decoder.d.ts

@@ -0,0 +1,24 @@
+import '@polkadot/types-codec';
+import { Block } from '../blockchain/block';
+import { DecoratedMeta } from '@polkadot/types/metadata/decorate/types';
+import { HexString } from '@polkadot/util/types';
+import { StorageEntry } from '@polkadot/types/primitive/types';
+import { StorageKey } from '@polkadot/types';
+export declare const decodeKey: (meta: DecoratedMeta, block: Block, key: HexString) => {
+    storage?: StorageEntry | undefined;
+    decodedKey?: StorageKey<import("@polkadot/types-codec/types").AnyTuple> | undefined;
+};
+export declare const decodeKeyValue: (meta: DecoratedMeta, block: Block, key: HexString, value?: HexString | null) => {
+    [x: string]: `0x${string}` | null | undefined;
+} | {
+    [x: string]: {
+        [x: string]: import("@polkadot/types-codec/types").AnyJson;
+    };
+};
+/**
+ * Decode block storage diff
+ * @param block Block to compare storage diff
+ * @param diff Storage diff
+ * @returns decoded old state and new state
+ */
+export declare const decodeBlockStorageDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<{}[]>;

package/lib/utils/decoder.js

@@ -0,0 +1,113 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBlockStorageDiff = exports.decodeKeyValue = exports.decodeKey = void 0;
+require("@polkadot/types-codec");
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const lodash_1 = __importDefault(require("lodash"));
+const _CACHE = {};
+const getCache = (uid) => {
+    if (!_CACHE[uid]) {
+        _CACHE[uid] = new Map();
+    }
+    return _CACHE[uid];
+};
+const getStorageEntry = (meta, block, key) => {
+    const cache = getCache(block.chain.uid);
+    for (const [prefix, storageEntry] of cache.entries()) {
+        if (key.startsWith(prefix))
+            return storageEntry;
+    }
+    for (const module of Object.values(meta.query)) {
+        for (const storage of Object.values(module)) {
+            const keyPrefix = (0, util_1.u8aToHex)(storage.keyPrefix());
+            if (key.startsWith(keyPrefix)) {
+                cache.set(keyPrefix, storage);
+                return storage;
+            }
+        }
+    }
+    return undefined;
+};
+const decodeKey = (meta, block, key) => {
+    const storage = getStorageEntry(meta, block, key);
+    const decodedKey = meta.registry.createType('StorageKey', key);
+    if (storage) {
+        decodedKey.setMeta(storage.meta);
+        return { storage, decodedKey };
+    }
+    return {};
+};
+exports.decodeKey = decodeKey;
+const decodeKeyValue = (meta, block, key, value) => {
+    const { storage, decodedKey } = (0, exports.decodeKey)(meta, block, key);
+    if (!storage || !decodedKey) {
+        return { [key]: value };
+    }
+    const decodeValue = () => {
+        if (!value)
+            return null;
+        if (storage.section === 'substrate' && storage.method === 'code') {
+            return `:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${(0, util_1.hexToU8a)(value).length} bytes)`;
+        }
+        return meta.registry.createType(decodedKey.outputType, (0, util_1.hexToU8a)(value)).toHuman();
+    };
+    switch (decodedKey.args.length) {
+        case 2: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: {
+                            [decodedKey.args[1].toString()]: decodeValue(),
+                        },
+                    },
+                },
+            };
+        }
+        case 1: {
+            return {
+                [storage.section]: {
+                    [storage.method]: {
+                        [decodedKey.args[0].toString()]: decodeValue(),
+                    },
+                },
+            };
+        }
+        default:
+            return {
+                [storage.section]: {
+                    [storage.method]: decodeValue(),
+                },
+            };
+    }
+};
+exports.decodeKeyValue = decodeKeyValue;
+/**
+ * Decode block storage diff
+ * @param block Block to compare storage diff
+ * @param diff Storage diff
+ * @returns decoded old state and new state
+ */
+const decodeBlockStorageDiff = (block, diff) => __awaiter(void 0, void 0, void 0, function* () {
+    const oldState = {};
+    const newState = {};
+    const meta = yield block.meta;
+    for (const [key, value] of diff) {
+        lodash_1.default.merge(oldState, (0, exports.decodeKeyValue)(meta, block, key, (yield block.get(key))));
+        lodash_1.default.merge(newState, (0, exports.decodeKeyValue)(meta, block, key, value));
+    }
+    return [oldState, newState];
+});
+exports.decodeBlockStorageDiff = decodeBlockStorageDiff;

package/lib/utils/index.d.ts

@@ -3,6 +3,7 @@ import { StorageKey } from '@polkadot/types';
 import { Blockchain } from '../blockchain';
 export * from './set-storage';
 export * from './time-travel';
+export * from './decoder';
 export type GetKeys = (startKey?: string) => Promise<StorageKey<any>[]>;
 export type ProcessKey = (key: StorageKey<any>) => any;
 export declare function fetchKeys(getKeys: GetKeys, processKey: ProcessKey): Promise<void>;

package/lib/utils/index.js

@@ -27,6 +27,7 @@ exports.defer = exports.isUrl = exports.getParaId = exports.compactHex = exports
 const util_1 = require("@polkadot/util");
 __exportStar(require("./set-storage"), exports);
 __exportStar(require("./time-travel"), exports);
+__exportStar(require("./decoder"), exports);
 function fetchKeys(getKeys, processKey) {
     return __awaiter(this, void 0, void 0, function* () {
         const processKeys = (keys) => __awaiter(this, void 0, void 0, function* () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.8.0-3",
+  "version": "0.8.0-5",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
   "license": "Apache-2.0",
   "scripts": {
@@ -9,8 +9,9 @@
     "build": "yarn pack-wasm; tsc -p ./tsconfig.json"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.8.0-3",
+    "@acala-network/chopsticks-executor": "0.8.0-5",
     "@polkadot/api": "^10.9.1",
+    "@polkadot/util-crypto": "^12.3.2",
     "axios": "^1.4.0",
     "eventemitter3": "^5.0.1",
     "localforage": "^1.10.0",
@@ -20,7 +21,7 @@
     "sql.js": "^1.8.0",
     "sqlite3": "^5.1.6",
     "typeorm": "^0.3.17",
-    "zod": "^3.21.4"
+    "zod": "^3.22.2"
   },
   "devDependencies": {
     "@types/lodash": "^4.14.197",