@acala-network/chopsticks-core 0.9.0 → 0.9.1-1

package/dist/cjs/utils/decoder.js

@@ -3,11 +3,11 @@ 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;
+exports.decodeBlockStorageDiff = exports.toStorageObject = 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 well_known_keys_1 = require("./well-known-keys");
 const _CACHE = {};
 const getCache = (uid) => {
     if (!_CACHE[uid]) {
@@ -43,48 +43,52 @@ const decodeKey = (meta, block, key) => {
 };
 exports.decodeKey = decodeKey;
 const decodeKeyValue = (meta, block, key, value, toHuman = true) => {
+    const res = (0, well_known_keys_1.decodeWellKnownKey)(meta.registry, key, value);
+    if (res) {
+        return {
+            section: 'substrate',
+            method: res.name,
+            key: res.key,
+            value: res.value,
+        };
+    }
     const { storage, decodedKey } = (0, exports.decodeKey)(meta, block, key);
     if (!storage || !decodedKey) {
-        return { [key]: value };
+        return undefined;
     }
     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 ? 'toHuman' : 'toJSON']();
     };
-    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(),
-                    },
-                },
-            };
+    return {
+        section: storage.section,
+        method: storage.method,
+        key: decodedKey.args,
+        value: decodeValue(),
+    };
+};
+exports.decodeKeyValue = decodeKeyValue;
+const toStorageObject = (decoded) => {
+    if (!decoded) {
+        return undefined;
+    }
+    const { section, method, key, value } = decoded;
+    let obj = value;
+    if (key) {
+        for (let i = key.length - 1; i >= 0; i--) {
+            const k = key[i];
+            const newObj = { [k.toString()]: obj };
+            obj = newObj;
         }
-        default:
-            return {
-                [storage.section]: {
-                    [storage.method]: decodeValue(),
-                },
-            };
     }
+    return {
+        [section]: {
+            [method]: obj,
+        },
+    };
 };
-exports.decodeKeyValue = decodeKeyValue;
+exports.toStorageObject = toStorageObject;
 /**
  * Decode block storage diff
  * @param block Block to compare storage diff
@@ -96,8 +100,11 @@ const decodeBlockStorageDiff = async (block, diff) => {
     const newState = {};
     const meta = await block.meta;
     for (const [key, value] of diff) {
-        lodash_1.default.merge(oldState, (0, exports.decodeKeyValue)(meta, block, key, (await block.get(key))));
-        lodash_1.default.merge(newState, (0, exports.decodeKeyValue)(meta, block, key, value));
+        const oldValue = await block.get(key);
+        const oldDecoded = (0, exports.toStorageObject)((0, exports.decodeKeyValue)(meta, block, key, oldValue)) ?? { [key]: oldValue };
+        lodash_1.default.merge(oldState, oldDecoded);
+        const newDecoded = (0, exports.toStorageObject)((0, exports.decodeKeyValue)(meta, block, key, value)) ?? { [key]: value };
+        lodash_1.default.merge(newState, newDecoded);
     }
     return [oldState, newState];
 };

package/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.printRuntimeLogs = 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.formatRuntimeLog = 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,12 +107,25 @@ const stripChildPrefix = (key) => {
     return storageKey;
 };
 exports.stripChildPrefix = stripChildPrefix;
+const logLevels = ['OFF', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'];
+const formatRuntimeLog = (log) => {
+    let msg = '';
+    if (log.level != null) {
+        msg += `${logLevels[log.level]}\t `;
+    }
+    if (log.target) {
+        msg += `[${log.target}]:\t `;
+    }
+    msg += log.message;
+    return msg;
+};
+exports.formatRuntimeLog = formatRuntimeLog;
 const printRuntimeLogs = (logs) => {
     if (!logs.length)
         return;
     console.group('RuntimeLogs:');
     for (const log of logs) {
-        console.log(log);
+        console.log((0, exports.formatRuntimeLog)(log));
     }
     console.groupEnd();
 };

package/dist/cjs/utils/well-known-keys.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeWellKnownKey = void 0;
+const util_crypto_1 = require("@polkadot/util-crypto");
+const util_1 = require("@polkadot/util");
+const decodeValue = (type) => (registry, value) => {
+    return registry.createType(type, (0, util_1.hexToU8a)(value)).toJSON();
+};
+// https://github.com/paritytech/polkadot-sdk/issues/2126
+const wellKnownKeys = [
+    {
+        name: 'code',
+        key: ':code',
+        decodeValue: (_registry, value) => {
+            return `<:code blake2_256 ${(0, util_crypto_1.blake2AsHex)(value, 256)} (${value.length / 2 - 1} bytes)>`;
+        },
+    },
+    {
+        name: 'heapPages',
+        key: ':heappages',
+        type: 'u64',
+    },
+    {
+        name: 'extrinsicIndex',
+        key: ':extrinsic_index',
+        type: 'u32',
+    },
+    {
+        name: 'intrablockEntropy',
+        key: ':intrablock_entropy',
+        type: '[u8; 32]',
+    },
+    {
+        name: 'transactionLevel',
+        key: ':transaction_level:',
+        type: 'u32',
+    },
+    {
+        name: 'grandpaAuthorities',
+        key: ':grandpa_authorities',
+        type: '(u8, AuthorityList)',
+    },
+    {
+        name: 'relayDispatchQueueRemainingCapacity',
+        prefix: ':relay_dispatch_queue_remaining_capacity',
+        decodeKey: (registry, key) => {
+            return [registry.createType('u32', (0, util_1.hexToU8a)(key)).toJSON()];
+        },
+        type: '(u32, u32)',
+    },
+].map((def) => {
+    const prefix = (0, util_1.stringToHex)(def.prefix || def.key);
+    return {
+        name: def.name,
+        prefix,
+        decodeKey: def.decodeKey || ((_registry, key) => [key]),
+        decodeValue: def.decodeValue || decodeValue(def.type),
+    };
+});
+const decodeWellKnownKey = (registry, key, value) => {
+    for (const defs of wellKnownKeys) {
+        if (key.startsWith(defs.prefix)) {
+            const remaining = key.slice(defs.prefix.length);
+            const decodedKey = remaining ? defs.decodeKey(registry, `0x${remaining}`) : undefined;
+            const decodedValue = value ? defs.decodeValue(registry, value) : undefined;
+            return {
+                name: defs.name,
+                key: decodedKey ?? [],
+                value: decodedValue,
+            };
+        }
+    }
+};
+exports.decodeWellKnownKey = decodeWellKnownKey;

package/dist/esm/utils/decoder.js

@@ -1,7 +1,7 @@
 import '@polkadot/types-codec';
-import { blake2AsHex } from '@polkadot/util-crypto';
 import { hexToU8a, u8aToHex } from '@polkadot/util';
 import _ from 'lodash';
+import { decodeWellKnownKey } from './well-known-keys';
 const _CACHE = {};
 const getCache = (uid) => {
     if (!_CACHE[uid]) {
@@ -36,46 +36,49 @@ export const decodeKey = (meta, block, key) => {
     return {};
 };
 export const decodeKeyValue = (meta, block, key, value, toHuman = true) => {
+    const res = decodeWellKnownKey(meta.registry, key, value);
+    if (res) {
+        return {
+            section: 'substrate',
+            method: res.name,
+            key: res.key,
+            value: res.value,
+        };
+    }
     const { storage, decodedKey } = decodeKey(meta, block, key);
     if (!storage || !decodedKey) {
-        return { [key]: value };
+        return undefined;
     }
     const decodeValue = () => {
         if (!value)
             return null;
-        if (storage.section === 'substrate' && storage.method === 'code') {
-            return `:code blake2_256 ${blake2AsHex(value, 256)} (${hexToU8a(value).length} bytes)`;
-        }
         return meta.registry.createType(decodedKey.outputType, hexToU8a(value))[toHuman ? 'toHuman' : 'toJSON']();
     };
-    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(),
-                    },
-                },
-            };
+    return {
+        section: storage.section,
+        method: storage.method,
+        key: decodedKey.args,
+        value: decodeValue(),
+    };
+};
+export const toStorageObject = (decoded) => {
+    if (!decoded) {
+        return undefined;
+    }
+    const { section, method, key, value } = decoded;
+    let obj = value;
+    if (key) {
+        for (let i = key.length - 1; i >= 0; i--) {
+            const k = key[i];
+            const newObj = { [k.toString()]: obj };
+            obj = newObj;
         }
-        default:
-            return {
-                [storage.section]: {
-                    [storage.method]: decodeValue(),
-                },
-            };
     }
+    return {
+        [section]: {
+            [method]: obj,
+        },
+    };
 };
 /**
  * Decode block storage diff
@@ -88,8 +91,11 @@ export const decodeBlockStorageDiff = async (block, diff) => {
     const newState = {};
     const meta = await block.meta;
     for (const [key, value] of diff) {
-        _.merge(oldState, decodeKeyValue(meta, block, key, (await block.get(key))));
-        _.merge(newState, decodeKeyValue(meta, block, key, value));
+        const oldValue = await block.get(key);
+        const oldDecoded = toStorageObject(decodeKeyValue(meta, block, key, oldValue)) ?? { [key]: oldValue };
+        _.merge(oldState, oldDecoded);
+        const newDecoded = toStorageObject(decodeKeyValue(meta, block, key, value)) ?? { [key]: value };
+        _.merge(newState, newDecoded);
     }
     return [oldState, newState];
 };

package/dist/esm/utils/index.js

@@ -80,12 +80,24 @@ export const stripChildPrefix = (key) => {
         return key;
     return storageKey;
 };
+const logLevels = ['OFF', 'ERROR', 'WARN', 'INFO', 'DEBUG', 'TRACE'];
+export const formatRuntimeLog = (log) => {
+    let msg = '';
+    if (log.level != null) {
+        msg += `${logLevels[log.level]}\t `;
+    }
+    if (log.target) {
+        msg += `[${log.target}]:\t `;
+    }
+    msg += log.message;
+    return msg;
+};
 export const printRuntimeLogs = (logs) => {
     if (!logs.length)
         return;
     console.group('RuntimeLogs:');
     for (const log of logs) {
-        console.log(log);
+        console.log(formatRuntimeLog(log));
     }
     console.groupEnd();
 };

package/dist/esm/utils/well-known-keys.js

@@ -0,0 +1,70 @@
+import { blake2AsHex } from '@polkadot/util-crypto';
+import { hexToU8a, stringToHex } from '@polkadot/util';
+const decodeValue = (type) => (registry, value) => {
+    return registry.createType(type, hexToU8a(value)).toJSON();
+};
+// https://github.com/paritytech/polkadot-sdk/issues/2126
+const wellKnownKeys = [
+    {
+        name: 'code',
+        key: ':code',
+        decodeValue: (_registry, value) => {
+            return `<:code blake2_256 ${blake2AsHex(value, 256)} (${value.length / 2 - 1} bytes)>`;
+        },
+    },
+    {
+        name: 'heapPages',
+        key: ':heappages',
+        type: 'u64',
+    },
+    {
+        name: 'extrinsicIndex',
+        key: ':extrinsic_index',
+        type: 'u32',
+    },
+    {
+        name: 'intrablockEntropy',
+        key: ':intrablock_entropy',
+        type: '[u8; 32]',
+    },
+    {
+        name: 'transactionLevel',
+        key: ':transaction_level:',
+        type: 'u32',
+    },
+    {
+        name: 'grandpaAuthorities',
+        key: ':grandpa_authorities',
+        type: '(u8, AuthorityList)',
+    },
+    {
+        name: 'relayDispatchQueueRemainingCapacity',
+        prefix: ':relay_dispatch_queue_remaining_capacity',
+        decodeKey: (registry, key) => {
+            return [registry.createType('u32', hexToU8a(key)).toJSON()];
+        },
+        type: '(u32, u32)',
+    },
+].map((def) => {
+    const prefix = stringToHex(def.prefix || def.key);
+    return {
+        name: def.name,
+        prefix,
+        decodeKey: def.decodeKey || ((_registry, key) => [key]),
+        decodeValue: def.decodeValue || decodeValue(def.type),
+    };
+});
+export const decodeWellKnownKey = (registry, key, value) => {
+    for (const defs of wellKnownKeys) {
+        if (key.startsWith(defs.prefix)) {
+            const remaining = key.slice(defs.prefix.length);
+            const decodedKey = remaining ? defs.decodeKey(registry, `0x${remaining}`) : undefined;
+            const decodedValue = value ? defs.decodeValue(registry, value) : undefined;
+            return {
+                name: defs.name,
+                key: decodedKey ?? [],
+                value: decodedValue,
+            };
+        }
+    }
+};

package/dist/types/blockchain/block-builder.d.ts

@@ -1,6 +1,7 @@
 import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
-import { Block, TaskCallResponse } from './block';
+import { Block } from './block';
 import { HexString } from '@polkadot/util/types';
+import { TaskCallResponse } from '../wasm-executor';
 export declare const newHeader: (head: Block, unsafeBlockHeight?: number) => Promise<Header>;
 export type BuildBlockCallbacks = {
     onApplyExtrinsicError?: (extrinsic: HexString, error: TransactionValidityError) => void;

package/dist/types/blockchain/block.d.ts

@@ -5,13 +5,7 @@ import { StorageEntry } from '@polkadot/types/primitive/types';
 import type { HexString } from '@polkadot/util/types';
 import { Blockchain } from '.';
 import { StorageLayer, StorageLayerProvider, StorageValue } from './storage-layer';
-import type { RuntimeVersion } from '../wasm-executor';
-export type TaskCallResponse = {
-    result: HexString;
-    storageDiff: [HexString, HexString | null][];
-    offchainStorageDiff: [HexString, HexString | null][];
-    runtimeLogs: string[];
-};
+import type { RuntimeVersion, TaskCallResponse } from '../wasm-executor';
 /**
  * Block class.
  *
@@ -53,7 +47,7 @@ export declare class Block {
     /**
      * Get the block storage by key.
      */
-    get(key: string): Promise<string | undefined>;
+    get(key: string): Promise<HexString | undefined>;
     read<T extends string>(type: T, query: StorageEntry, ...args: any[]): Promise<import("@polkadot/types/types").DetectCodec<import("@polkadot/types-codec/types").Codec, T> | undefined>;
     /**
      * Get paged storage keys.

package/dist/types/utils/decoder.d.ts

@@ -9,12 +9,16 @@ export declare const decodeKey: (meta: DecoratedMeta, block: Block, key: HexStri
     decodedKey?: StorageKey<import("@polkadot/types-codec/types").AnyTuple> | undefined;
 };
 export declare const decodeKeyValue: (meta: DecoratedMeta, block: Block, key: HexString, value?: HexString | null, toHuman?: boolean) => {
-    [x: string]: `0x${string}` | null | undefined;
-} | {
+    section: string;
+    method: string;
+    key: any[];
+    value: import("@polkadot/types-codec/types").AnyJson;
+} | undefined;
+export declare const toStorageObject: (decoded: ReturnType<typeof decodeKeyValue>) => {
     [x: string]: {
         [x: string]: import("@polkadot/types-codec/types").AnyJson;
     };
-};
+} | undefined;
 /**
  * Decode block storage diff
  * @param block Block to compare storage diff

package/dist/types/utils/index.d.ts

@@ -1,6 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { StorageKey } from '@polkadot/types';
 import { Blockchain } from '../blockchain';
+import { RuntimeLog } from '../wasm-executor';
 export * from './set-storage';
 export * from './time-travel';
 export * from './decoder';
@@ -21,4 +22,5 @@ export declare const prefixedChildKey: (prefix: HexString, key: HexString) => st
 export declare const isPrefixedChildKey: (key: HexString) => boolean;
 export declare const splitChildKey: (key: HexString) => never[] | [`0x${string}`, `0x${string}`];
 export declare const stripChildPrefix: (key: HexString) => `0x${string}`;
-export declare const printRuntimeLogs: (logs: string[]) => void;
+export declare const formatRuntimeLog: (log: RuntimeLog) => string;
+export declare const printRuntimeLogs: (logs: RuntimeLog[]) => void;

package/dist/types/utils/well-known-keys.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Registry } from '@polkadot/types-codec/types';
+export declare const decodeWellKnownKey: (registry: Registry, key: HexString, value?: HexString | null) => {
+    name: string;
+    key: any[];
+    value: import("@polkadot/types-codec/types").AnyJson;
+} | undefined;

package/dist/types/wasm-executor/index.d.ts

@@ -14,13 +14,19 @@ export type RuntimeVersion = {
     transactionVersion: number;
     stateVersion: number;
 };
+export type RuntimeLog = {
+    message: string;
+    level?: number;
+    target?: string;
+};
+export type TaskCallResponse = {
+    result: HexString;
+    storageDiff: [HexString, HexString | null][];
+    offchainStorageDiff: [HexString, HexString | null][];
+    runtimeLogs: RuntimeLog[];
+};
 export type TaskResponse = {
-    Call: {
-        result: HexString;
-        storageDiff: [HexString, HexString | null][];
-        offchainStorageDiff: [HexString, HexString | null][];
-        runtimeLogs: string[];
-    };
+    Call: TaskCallResponse;
 } | {
     Error: string;
 };
@@ -51,12 +57,7 @@ export declare const runTask: (task: {
     allowUnresolvedImports: boolean;
     runtimeLogLevel: number;
 }, callback?: JsCallback) => Promise<{
-    Call: {
-        result: HexString;
-        storageDiff: [HexString, HexString | null][];
-        offchainStorageDiff: [HexString, HexString | null][];
-        runtimeLogs: string[];
-    };
+    Call: TaskCallResponse;
 } | {
     Error: string;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.9.0",
+  "version": "0.9.1-1",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "scripts": {
@@ -10,13 +10,13 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.9.0",
+    "@acala-network/chopsticks-executor": "0.9.1-1",
     "@polkadot/api": "^10.10.1",
     "@polkadot/util-crypto": "^12.5.1",
     "comlink": "^4.4.1",
     "eventemitter3": "^5.0.1",
     "lodash": "^4.17.21",
-    "pino": "^8.15.0",
+    "pino": "^8.16.1",
     "pino-pretty": "^10.2.0",
     "zod": "^3.22.3"
   },