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

package/dist/cjs/blockchain/inherent/parachain/validation-data.js

@@ -71,13 +71,7 @@ class SetValidationData {
             const dmqMqcHeadKey = (0, _proof.dmqMqcHead)(paraId);
             const hrmpIngressChannelIndexKey = (0, _proof.hrmpIngressChannelIndex)(paraId);
             const hrmpEgressChannelIndexKey = (0, _proof.hrmpEgressChannelIndex)(paraId);
-            // TODO: refactor this to have a single decodeProof
-            const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                ...Object.values(_proof.WELL_KNOWN_KEYS),
-                dmqMqcHeadKey,
-                hrmpIngressChannelIndexKey,
-                hrmpEgressChannelIndexKey
-            ], extrinsic.relayChainState.trieNodes);
+            const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes);
             for (const key of Object.values(_proof.WELL_KNOWN_KEYS)){
                 if (key === _proof.WELL_KNOWN_KEYS.CURRENT_SLOT) {
                     // increment current slot
@@ -140,9 +134,6 @@ class SetValidationData {
                     receiver: paraId.toNumber()
                 });
                 const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
-                const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 const abridgedHrmpRaw = decoded[hrmpChannelKey];
                 if (!abridgedHrmpRaw) throw new Error('Canoot find hrmp channels from validation data');
                 const abridgedHrmp = meta.registry.createType('AbridgedHrmpChannel', (0, _util.hexToU8a)(abridgedHrmpRaw)).toJSON();
@@ -175,9 +166,6 @@ class SetValidationData {
                     receiver
                 });
                 const hrmpChannelKey = (0, _proof.hrmpChannels)(channelId);
-                const decoded = await (0, _index1.decodeProof)(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 newEntries.push([
                     hrmpChannelKey,
                     decoded[hrmpChannelKey]

package/dist/cjs/rpc/substrate/author.js

@@ -72,6 +72,12 @@ const author_submitAndWatchExtrinsic = async (context, [extrinsic], { subscribe,
             callback({
                 ready: null
             });
+            // fake broadcast to alice peer
+            callback({
+                broadcast: [
+                    '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+                ]
+            });
         }, 50);
     } catch (error) {
         logger.error({

package/dist/cjs/utils/decoder.js

@@ -27,11 +27,15 @@ const _lrucache = require("lru-cache");
 const _util = require("@polkadot/util");
 const _lodash = /*#__PURE__*/ _interop_require_default(require("lodash"));
 const _wellknownkeys = require("./well-known-keys.js");
+const _logger = require("../logger.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+const logger = _logger.defaultLogger.child({
+    module: 'decoder'
+});
 const _CACHE = {};
 function createCache() {
     return new _lrucache.LRUCache({
@@ -85,11 +89,27 @@ 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, (0, _util.hexToU8a)(value))[toHuman ? 'toHuman' : 'toJSON']();
+        try {
+            return meta.registry.createType(decodedKey.outputType, (0, _util.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/cjs/wasm-executor/browser-wasm-executor.js

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

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

@@ -33,8 +33,8 @@ export type TaskResponse = {
 export interface WasmExecutor {
     getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
     calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
-    createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<[HexString, HexString[]]>;
-    decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<[[HexString, HexString | null]]>;
+    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[]][];
@@ -50,8 +50,10 @@ export declare const getWorker: () => Promise<{
 }>;
 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, keys: HexString[], nodes: HexString[]) => Promise<{}>;
-export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
+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}`[];
 }>;

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

@@ -120,17 +120,17 @@ const calculateStateRoot = async (entries, trie_version)=>{
     const worker = await getWorker();
     return worker.remote.calculateStateRoot(entries, trie_version);
 };
-const decodeProof = async (trieRootHash, keys, nodes)=>{
+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;
     }, {});
 };
-const createProof = async (nodes, entries)=>{
+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/cjs/wasm-executor/node-wasm-executor.js

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

package/dist/esm/blockchain/inherent/parachain/validation-data.js

@@ -56,13 +56,7 @@ export class SetValidationData {
             const dmqMqcHeadKey = dmqMqcHead(paraId);
             const hrmpIngressChannelIndexKey = hrmpIngressChannelIndex(paraId);
             const hrmpEgressChannelIndexKey = hrmpEgressChannelIndex(paraId);
-            // TODO: refactor this to have a single decodeProof
-            const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                ...Object.values(WELL_KNOWN_KEYS),
-                dmqMqcHeadKey,
-                hrmpIngressChannelIndexKey,
-                hrmpEgressChannelIndexKey
-            ], extrinsic.relayChainState.trieNodes);
+            const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, extrinsic.relayChainState.trieNodes);
             for (const key of Object.values(WELL_KNOWN_KEYS)){
                 if (key === WELL_KNOWN_KEYS.CURRENT_SLOT) {
                     // increment current slot
@@ -125,9 +119,6 @@ export class SetValidationData {
                     receiver: paraId.toNumber()
                 });
                 const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 const abridgedHrmpRaw = decoded[hrmpChannelKey];
                 if (!abridgedHrmpRaw) throw new Error('Canoot find hrmp channels from validation data');
                 const abridgedHrmp = meta.registry.createType('AbridgedHrmpChannel', hexToU8a(abridgedHrmpRaw)).toJSON();
@@ -160,9 +151,6 @@ export class SetValidationData {
                     receiver
                 });
                 const hrmpChannelKey = hrmpChannels(channelId);
-                const decoded = await decodeProof(extrinsic.validationData.relayParentStorageRoot, [
-                    hrmpChannelKey
-                ], extrinsic.relayChainState.trieNodes);
                 newEntries.push([
                     hrmpChannelKey,
                     decoded[hrmpChannelKey]

package/dist/esm/rpc/substrate/author.js

@@ -59,6 +59,12 @@ const logger = defaultLogger.child({
             callback({
                 ready: null
             });
+            // fake broadcast to alice peer
+            callback({
+                broadcast: [
+                    '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY'
+                ]
+            });
         }, 50);
     } catch (error) {
         logger.error({

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/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/index.d.ts

@@ -33,8 +33,8 @@ export type TaskResponse = {
 export interface WasmExecutor {
     getRuntimeVersion: (code: HexString) => Promise<RuntimeVersion>;
     calculateStateRoot: (entries: [HexString, HexString][], trie_version: number) => Promise<HexString>;
-    createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<[HexString, HexString[]]>;
-    decodeProof: (trieRootHash: HexString, keys: HexString[], nodes: HexString[]) => Promise<[[HexString, HexString | null]]>;
+    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[]][];
@@ -50,8 +50,10 @@ export declare const getWorker: () => Promise<{
 }>;
 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, keys: HexString[], nodes: HexString[]) => Promise<{}>;
-export declare const createProof: (nodes: HexString[], entries: [HexString, HexString | null][]) => Promise<{
+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}`[];
 }>;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.9.4-3",
+  "version": "0.9.4-4",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
@@ -12,7 +12,7 @@
     "docs:prep": "typedoc"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.9.4-3",
+    "@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",