@acala-network/chopsticks-core 0.8.0-4 → 0.8.0-6

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-builder.d.ts

@@ -1,8 +1,8 @@
 import { Header, TransactionValidityError } from '@polkadot/types/interfaces';
 import { Block, TaskCallResponse } from './block';
 import { HexString } from '@polkadot/util/types';
-export declare const newHeader: (head: Block) => Promise<Header>;
-export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void) => Promise<[Block, HexString[]]>;
+export declare const newHeader: (head: Block, unsafeBlockHeight?: number) => Promise<Header>;
+export declare const buildBlock: (head: Block, inherents: HexString[], extrinsics: HexString[], ump: Record<number, HexString[]>, onApplyExtrinsicError: (extrinsic: HexString, error: TransactionValidityError) => void, unsafeBlockHeight?: number) => Promise<[Block, HexString[]]>;
 export declare const dryRunExtrinsic: (head: Block, inherents: HexString[], extrinsic: HexString | {
     call: HexString;
     address: string;

package/lib/blockchain/block-builder.js

@@ -42,7 +42,7 @@ const getNewSlot = (digest, slotNumber) => {
     }
     return digest.toJSON();
 };
-const newHeader = (head) => __awaiter(void 0, void 0, void 0, function* () {
+const newHeader = (head, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     const meta = yield head.meta;
     const parentHeader = yield head.header;
@@ -80,7 +80,7 @@ const newHeader = (head) => __awaiter(void 0, void 0, void 0, function* () {
     }
     const header = meta.registry.createType('Header', {
         parentHash: head.hash,
-        number: head.number + 1,
+        number: unsafeBlockHeight !== null && unsafeBlockHeight !== void 0 ? unsafeBlockHeight : head.number + 1,
         stateRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
         extrinsicsRoot: '0x0000000000000000000000000000000000000000000000000000000000000000',
         digest: {
@@ -126,14 +126,18 @@ const initNewBlock = (head, header, inherents, storageLayer) => __awaiter(void 0
         layers: layers,
     };
 });
-const buildBlock = (head, inherents, extrinsics, ump, onApplyExtrinsicError) => __awaiter(void 0, void 0, void 0, function* () {
+const buildBlock = (head, inherents, extrinsics, ump, onApplyExtrinsicError, unsafeBlockHeight) => __awaiter(void 0, void 0, void 0, function* () {
     const registry = yield head.registry;
-    const header = yield (0, exports.newHeader)(head);
+    const header = yield (0, exports.newHeader)(head, unsafeBlockHeight);
+    const newBlockNumber = header.number.toNumber();
+    if (newBlockNumber < head.number) {
+        throw new Error('unsafeBlockHeight is not allowed to be less than current block number');
+    }
     logger.info({
-        number: head.number + 1,
+        number: newBlockNumber,
         extrinsicsCount: extrinsics.length,
         umpCount: Object.keys(ump).length,
-    }, `Try building block #${(head.number + 1).toLocaleString()}`);
+    }, `Try building block #${newBlockNumber.toLocaleString()}`);
     let layer;
     // apply ump via storage override hack
     if (Object.keys(ump).length > 0) {

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.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);
                             }

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

@@ -21,6 +21,7 @@ export interface BuildBlockParams {
     upwardMessages: Record<number, HexString[]>;
     horizontalMessages: Record<number, HorizontalMessage[]>;
     transactions: HexString[];
+    unsafeBlockHeight?: number;
 }
 export declare class TxPool {
     #private;

package/lib/blockchain/txpool.js

@@ -131,6 +131,7 @@ class TxPool {
             const upwardMessages = (params === null || params === void 0 ? void 0 : params.upwardMessages) || Object.assign({}, __classPrivateFieldGet(this, _TxPool_ump, "f"));
             const downwardMessages = (params === null || params === void 0 ? void 0 : params.downwardMessages) || __classPrivateFieldGet(this, _TxPool_dmp, "f").splice(0);
             const horizontalMessages = (params === null || params === void 0 ? void 0 : params.horizontalMessages) || Object.assign({}, __classPrivateFieldGet(this, _TxPool_hrmp, "f"));
+            const unsafeBlockHeight = params === null || params === void 0 ? void 0 : params.unsafeBlockHeight;
             if (!(params === null || params === void 0 ? void 0 : params.upwardMessages)) {
                 for (const id of Object.keys(__classPrivateFieldGet(this, _TxPool_ump, "f"))) {
                     delete __classPrivateFieldGet(this, _TxPool_ump, "f")[id];
@@ -146,6 +147,7 @@ class TxPool {
                 upwardMessages,
                 downwardMessages,
                 horizontalMessages,
+                unsafeBlockHeight,
             });
         });
     }
@@ -206,7 +208,7 @@ _TxPool_chain = new WeakMap(), _TxPool_pool = new WeakMap(), _TxPool_ump = new W
         const inherents = yield __classPrivateFieldGet(this, _TxPool_inherentProvider, "f").createInherents(head, params);
         const [newBlock, pendingExtrinsics] = yield (0, block_builder_1.buildBlock)(head, inherents, params.transactions, params.upwardMessages, (extrinsic, error) => {
             this.event.emit(exports.APPLY_EXTRINSIC_ERROR, [extrinsic, error]);
-        });
+        }, params.unsafeBlockHeight);
         for (const extrinsic of pendingExtrinsics) {
             __classPrivateFieldGet(this, _TxPool_pool, "f").push({ extrinsic, signer: yield __classPrivateFieldGet(this, _TxPool_instances, "m", _TxPool_getSigner).call(this, extrinsic) });
         }

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

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.8.0-4",
+  "version": "0.8.0-6",
   "author": "Bryan Chen <xlchen1291@gmail.com>",
   "license": "Apache-2.0",
   "scripts": {
@@ -9,9 +9,10 @@
     "build": "yarn pack-wasm; tsc -p ./tsconfig.json"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.8.0-4",
+    "@acala-network/chopsticks-executor": "0.8.0-6",
     "@polkadot/api": "^10.9.1",
-    "axios": "^1.4.0",
+    "@polkadot/util-crypto": "^12.3.2",
+    "axios": "^1.5.0",
     "eventemitter3": "^5.0.1",
     "localforage": "^1.10.0",
     "lodash": "^4.17.21",
@@ -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",