@acala-network/chopsticks-core 0.9.4-2 → 0.9.4-4

package/dist/esm/setup.d.ts

@@ -0,0 +1,20 @@
+import '@polkadot/types-codec';
+import { RegisteredTypes } from '@polkadot/types/types';
+import { Blockchain } from './blockchain/index.js';
+import { BuildBlockMode } from './blockchain/txpool.js';
+import { Database } from './database.js';
+import { GenesisProvider } from './genesis-provider.js';
+export type SetupOptions = {
+    endpoint?: string | string[];
+    block?: string | number | null;
+    genesis?: GenesisProvider;
+    buildBlockMode?: BuildBlockMode;
+    db?: Database;
+    mockSignatureHost?: boolean;
+    allowUnresolvedImports?: boolean;
+    runtimeLogLevel?: number;
+    registeredTypes?: RegisteredTypes;
+    offchainWorker?: boolean;
+    maxMemoryBlockCount?: number;
+};
+export declare const setup: (options: SetupOptions) => Promise<Blockchain>;

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

@@ -0,0 +1,28 @@
+import '@polkadot/types-codec';
+import { Block } from '../blockchain/block.js';
+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, toHuman?: boolean) => {
+    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
+ * @param diff Storage diff
+ * @returns decoded old state and new state
+ */
+export declare const decodeBlockStorageDiff: (block: Block, diff: [HexString, HexString | null][]) => Promise<{}[]>;

package/dist/esm/utils/decoder.js

@@ -3,6 +3,10 @@ import { LRUCache } from 'lru-cache';
 import { hexToU8a, u8aToHex } from '@polkadot/util';
 import _ from 'lodash';
 import { decodeWellKnownKey } from './well-known-keys.js';
+import { defaultLogger } from '../logger.js';
+const logger = defaultLogger.child({
+    module: 'decoder'
+});
 const _CACHE = {};
 function createCache() {
     return new LRUCache({
@@ -56,11 +60,27 @@ export const decodeKeyValue = (meta, block, key, value, toHuman = true)=>{
     }
     const { storage, decodedKey } = decodeKey(meta, block, key);
     if (!storage || !decodedKey) {
+        logger.warn({
+            key,
+            value
+        }, 'Failed to decode storage key');
         return undefined;
     }
     const decodeValue = ()=>{
         if (!value) return null;
-        return meta.registry.createType(decodedKey.outputType, hexToU8a(value))[toHuman ? 'toHuman' : 'toJSON']();
+        try {
+            return meta.registry.createType(decodedKey.outputType, hexToU8a(value))[toHuman ? 'toHuman' : 'toJSON']();
+        } catch (error) {
+            logger.warn(error, 'Failed to decode storage value');
+            logger.warn({
+                key,
+                value,
+                section: storage.section,
+                method: storage.method,
+                args: decodedKey.args
+            }, 'Failed to decode storage value');
+            return undefined;
+        }
     };
     return {
         section: storage.section,

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

@@ -0,0 +1,23 @@
+import { HexString } from '@polkadot/util/types';
+import { StorageKey } from '@polkadot/types';
+import { Blockchain } from '../blockchain/index.js';
+export * from './set-storage.js';
+export * from './time-travel.js';
+export * from './decoder.js';
+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>;
+export declare function fetchKeysToArray(getKeys: GetKeys): Promise<StorageKey<any>[]>;
+export declare const compactHex: (value: Uint8Array) => HexString;
+export declare const getParaId: (chain: Blockchain) => Promise<import("@polkadot/types").U32>;
+export declare const isUrl: (url: string) => boolean;
+export type Deferred<T> = {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+};
+export declare function defer<T>(): Deferred<T>;
+export declare const prefixedChildKey: (prefix: HexString, key: HexString) => string;
+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}`;

package/dist/esm/utils/key-cache.d.ts

@@ -0,0 +1,10 @@
+import { HexString } from '@polkadot/util/types';
+export declare const PREFIX_LENGTH = 66;
+export default class KeyCache {
+    readonly ranges: Array<{
+        prefix: string;
+        keys: string[];
+    }>;
+    feed(keys: HexString[]): void;
+    next(startKey: HexString): Promise<HexString | undefined>;
+}

package/dist/esm/utils/proof.d.ts

@@ -0,0 +1,16 @@
+import { HrmpChannelId } from '@polkadot/types/interfaces';
+import { u32 } from '@polkadot/types';
+export declare const WELL_KNOWN_KEYS: {
+    EPOCH_INDEX: `0x${string}`;
+    CURRENT_BLOCK_RANDOMNESS: `0x${string}`;
+    ONE_EPOCH_AGO_RANDOMNESS: `0x${string}`;
+    TWO_EPOCHS_AGO_RANDOMNESS: `0x${string}`;
+    CURRENT_SLOT: `0x${string}`;
+    ACTIVE_CONFIG: `0x${string}`;
+};
+export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
+export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
+export declare const hrmpIngressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpEgressChannelIndex: (paraId: u32) => `0x${string}`;
+export declare const hrmpChannels: (channelId: HrmpChannelId) => `0x${string}`;
+export declare const paraHead: (paraId: u32) => `0x${string}`;

package/dist/esm/utils/set-storage.d.ts

@@ -0,0 +1,7 @@
+import { HexString } from '@polkadot/util/types';
+import { Blockchain } from '../blockchain/index.js';
+type RawStorageValues = [string, string | null][];
+type StorageConfig = Record<string, Record<string, any>>;
+export type StorageValues = RawStorageValues | StorageConfig;
+export declare const setStorage: (chain: Blockchain, storage: StorageValues, blockHash?: HexString) => Promise<HexString>;
+export {};

package/dist/esm/utils/time-travel.d.ts

@@ -0,0 +1,5 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const getCurrentSlot: (chain: Blockchain) => Promise<number>;
+export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<bigint>;
+export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;
+export declare const timeTravel: (chain: Blockchain, timestamp: number) => Promise<void>;

package/dist/esm/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/esm/wasm-executor/browser-wasm-executor.js

@@ -7,11 +7,11 @@ const getRuntimeVersion = async (code)=>{
 const calculateStateRoot = async (entries, trie_version)=>{
     return pkg.calculate_state_root(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
-    return pkg.decode_proof(trieRootHash, keys, nodes);
+const decodeProof = async (trieRootHash, nodes)=>{
+    return pkg.decode_proof(trieRootHash, nodes);
 };
-const createProof = async (nodes, entries)=>{
-    return pkg.create_proof(nodes, entries);
+const createProof = async (nodes, updates)=>{
+    return pkg.create_proof(nodes, updates);
 };
 const runTask = async (task, callback)=>{
     return pkg.run_task(task, callback, 'info');

package/dist/esm/wasm-executor/browser-worker.d.ts

@@ -0,0 +1,4 @@
+export declare const startWorker: <T>() => Promise<{
+    remote: import("comlink").Remote<T>;
+    terminate: () => Promise<void>;
+}>;

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

@@ -0,0 +1,82 @@
+import * as Comlink from 'comlink';
+import { HexString } from '@polkadot/util/types';
+import _ from 'lodash';
+import { Block } from '../blockchain/block.js';
+import type { JsCallback } from '@acala-network/chopsticks-executor';
+export { JsCallback };
+export type RuntimeVersion = {
+    specName: string;
+    implName: string;
+    authoringVersion: number;
+    specVersion: number;
+    implVersion: number;
+    apis: [HexString, number][];
+    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: TaskCallResponse;
+} | {
+    Error: string;
+};
+export interface WasmExecutor {
+    getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
+    calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
+    createProof: (nodes: HexString[], updates: [HexString, HexString | null][]) => Promise<[HexString, HexString[]]>;
+    decodeProof: (trieRootHash: HexString, nodes: HexString[]) => Promise<[[HexString, HexString]]>;
+    runTask: (task: {
+        wasm: HexString;
+        calls: [string, HexString[]][];
+        mockSignatureHost: boolean;
+        allowUnresolvedImports: boolean;
+        runtimeLogLevel: number;
+    }, callback?: JsCallback) => Promise<TaskResponse>;
+    testing: (callback: JsCallback, key: any) => Promise<any>;
+}
+export declare const getWorker: () => Promise<{
+    remote: Comlink.Remote<WasmExecutor>;
+    terminate: () => Promise<void>;
+}>;
+export declare const getRuntimeVersion: ((code: HexString) => Promise<RuntimeVersion>) & _.MemoizedFunction;
+export declare const calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
+export declare const decodeProof: (trieRootHash: HexString, nodes: HexString[]) => Promise<{
+    [key: `0x${string}`]: `0x${string}`;
+}>;
+export declare const createProof: (nodes: HexString[], updates: [HexString, HexString | null][]) => Promise<{
+    trieRootHash: `0x${string}`;
+    nodes: `0x${string}`[];
+}>;
+export declare const runTask: (task: {
+    wasm: HexString;
+    calls: [string, HexString[]][];
+    mockSignatureHost: boolean;
+    allowUnresolvedImports: boolean;
+    runtimeLogLevel: number;
+}, callback?: JsCallback) => Promise<{
+    Call: TaskCallResponse;
+} | {
+    Error: string;
+}>;
+export declare const taskHandler: (block: Block) => JsCallback;
+export declare const emptyTaskHandler: {
+    getStorage: (_key: HexString) => Promise<never>;
+    getStateRoot: () => Promise<never>;
+    getNextKey: (_prefix: HexString, _key: HexString) => Promise<never>;
+    offchainGetStorage: (_key: HexString) => Promise<never>;
+    offchainTimestamp: () => Promise<never>;
+    offchainRandomSeed: () => Promise<never>;
+    offchainSubmitTransaction: (_tx: HexString) => Promise<never>;
+};
+export declare const getAuraSlotDuration: ((wasm: HexString) => Promise<number>) & _.MemoizedFunction;
+export declare const destroyWorker: () => Promise<void>;

package/dist/esm/wasm-executor/index.js

@@ -33,17 +33,17 @@ export const calculateStateRoot = async (entries, trie_version)=>{
     const worker = await getWorker();
     return worker.remote.calculateStateRoot(entries, trie_version);
 };
-export const decodeProof = async (trieRootHash, keys, nodes)=>{
+export const decodeProof = async (trieRootHash, nodes)=>{
     const worker = await getWorker();
-    const result = await worker.remote.decodeProof(trieRootHash, keys, nodes);
+    const result = await worker.remote.decodeProof(trieRootHash, nodes);
     return result.reduce((accum, [key, value])=>{
         accum[key] = value;
         return accum;
     }, {});
 };
-export const createProof = async (nodes, entries)=>{
+export const createProof = async (nodes, updates)=>{
     const worker = await getWorker();
-    const [trieRootHash, newNodes] = await worker.remote.createProof(nodes, entries);
+    const [trieRootHash, newNodes] = await worker.remote.createProof(nodes, updates);
     return {
         trieRootHash,
         nodes: newNodes

package/dist/esm/wasm-executor/node-wasm-executor.js

@@ -9,11 +9,11 @@ const getRuntimeVersion = async (code)=>{
 const calculateStateRoot = async (entries, trie_version)=>{
     return pkg.calculate_state_root(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
-    return pkg.decode_proof(trieRootHash, keys, nodes);
+const decodeProof = async (trieRootHash, nodes)=>{
+    return pkg.decode_proof(trieRootHash, nodes);
 };
-const createProof = async (nodes, entries)=>{
-    return pkg.create_proof(nodes, entries);
+const createProof = async (nodes, updates)=>{
+    return pkg.create_proof(nodes, updates);
 };
 const runTask = async (task, callback)=>{
     return pkg.run_task(task, callback, process.env.RUST_LOG);

package/dist/esm/wasm-executor/node-worker.d.ts

@@ -0,0 +1,4 @@
+export declare const startWorker: <T>() => Promise<{
+    remote: import("comlink").Remote<T>;
+    terminate: () => Promise<void>;
+}>;

package/dist/esm/xcm/downward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const connectDownward: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;

package/dist/esm/xcm/horizontal.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const connectHorizontal: (parachains: Record<number, Blockchain>) => Promise<void>;

package/dist/esm/xcm/index.d.ts

@@ -0,0 +1,9 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const logger: import("pino").default.Logger<{
+    level: string;
+    transport: {
+        target: string;
+    };
+}>;
+export declare const connectVertical: (relaychain: Blockchain, parachain: Blockchain) => Promise<void>;
+export declare const connectParachains: (parachains: Blockchain[]) => Promise<void>;

package/dist/esm/xcm/upward.d.ts

@@ -0,0 +1,2 @@
+import { Blockchain } from '../blockchain/index.js';
+export declare const connectUpward: (parachain: Blockchain, relaychain: Blockchain) => Promise<void>;

package/package.json

@@ -1,19 +1,18 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.9.4-2",
+  "version": "0.9.4-4",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
   "scripts": {
-    "clean": "rm -rf dist",
-    "build": "yarn clean && yarn build:cjs && yarn build:esm && yarn build:types",
-    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
-    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm",
-    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --outDir dist/types",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "build": "yarn clean && yarn build:cjs && yarn build:esm",
+    "build:cjs": "swc ./src --config-file ../../.cjsswcrc -d dist/cjs && tsc -p tsconfig.json --declarationDir dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json",
+    "build:esm": "swc ./src --config-file ../../.esmswcrc -d dist/esm && tsc -p tsconfig.json --declarationDir dist/esm",
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.9.4-2",
+    "@acala-network/chopsticks-executor": "0.9.4-4",
     "@polkadot/rpc-provider": "^10.10.1",
     "@polkadot/types": "^10.10.1",
     "@polkadot/types-codec": "^10.10.1",
@@ -38,27 +37,21 @@
   },
   "files": [
     "dist/esm/**",
-    "dist/cjs/**",
-    "dist/types/**"
+    "dist/cjs/**"
   ],
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",
-  "types": "./dist/types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/types/index.d.ts",
       "require": "./dist/cjs/index.js",
       "import": "./dist/esm/index.js",
       "default": "./dist/esm/index.js"
     },
     "./*": {
-      "types": "./dist/types/*.d.ts",
       "require": "./dist/cjs/*.js",
       "import": "./dist/esm/*.js",
       "default": "./dist/esm/*.js"
-    },
-    "./package.json": "./package.json",
-    "./package.cjs.json": "./dist/cjs/package.json"
+    }
   },
   "browser": {
     "./dist/cjs/wasm-executor/node-worker.js": "./dist/cjs/wasm-executor/browser-worker.js",