@acala-network/chopsticks-core 0.9.8-1 → 0.9.8-2

package/dist/esm/blockchain/inherent/para-enter.js

@@ -1,6 +1,8 @@
 import { GenericExtrinsic } from '@polkadot/types';
 export class ParaInherentEnter {
-    async createInherents(parent, _params) {
+    async createInherents(newBlock, _params) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
         const meta = await parent.meta;
         if (!meta.tx.paraInherent?.enter) {
             return [];

package/dist/esm/blockchain/inherent/parachain/babe-randomness.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from '../../block.js';
 import { BuildBlockParams } from '../../txpool.js';
-import { CreateInherents } from '../index.js';
-export declare class SetBabeRandomness implements CreateInherents {
-    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+import { InherentProvider } from '../index.js';
+export declare class SetBabeRandomness implements InherentProvider {
+    createInherents(newBlock: Block, _params: BuildBlockParams): Promise<HexString[]>;
 }

package/dist/esm/blockchain/inherent/parachain/babe-randomness.js

@@ -1,7 +1,9 @@
 import { GenericExtrinsic } from '@polkadot/types';
 // Support for Moonbeam pallet-randomness mandatory inherent
 export class SetBabeRandomness {
-    async createInherents(parent, _params) {
+    async createInherents(newBlock, _params) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
         const meta = await parent.meta;
         if (!meta.tx.randomness?.setBabeRandomnessResults) {
             return [];

package/dist/esm/blockchain/inherent/parachain/nimbus-author-inherent.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from '../../block.js';
 import { BuildBlockParams } from '../../txpool.js';
-import { CreateInherents } from '../index.js';
-export declare class SetNimbusAuthorInherent implements CreateInherents {
-    createInherents(parent: Block, _params: BuildBlockParams): Promise<HexString[]>;
+import { InherentProvider } from '../index.js';
+export declare class SetNimbusAuthorInherent implements InherentProvider {
+    createInherents(newBlock: Block, _params: BuildBlockParams): Promise<HexString[]>;
 }

package/dist/esm/blockchain/inherent/parachain/nimbus-author-inherent.js

@@ -1,11 +1,30 @@
 import { GenericExtrinsic } from '@polkadot/types';
+import { compactHex } from '../../../utils/index.js';
 // Support for Nimbus Author Inherent
 export class SetNimbusAuthorInherent {
-    async createInherents(parent, _params) {
+    async createInherents(newBlock, _params) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
         const meta = await parent.meta;
         if (!meta.tx.authorInherent?.kickOffAuthorshipValidation) {
             return [];
         }
+        // mock author inherent data and authorities noting data
+        const layer = newBlock.pushStorageLayer();
+        const accountType = meta.registry.hasType('NimbusPrimitivesNimbusCryptoPublic') ? 'NimbusPrimitivesNimbusCryptoPublic' : 'AccountId';
+        const alice = meta.registry.hasType('NimbusPrimitivesNimbusCryptoPublic') ? '0x567b6ddb05396c0a83853b6f40d27450534c7963df8619b8c6064480c4db9703' : '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY';
+        layer.set(compactHex(meta.query.authorInherent.author()), meta.registry.createType(accountType, alice).toHex());
+        if (meta.query.authoritiesNoting) {
+            layer.set(compactHex(meta.query.authoritiesNoting.authorities()), meta.registry.createType(`Vec<${accountType}>`, [
+                alice
+            ]).toHex());
+            layer.set(compactHex(meta.query.authoritiesNoting.didSetOrchestratorAuthorityData()), meta.registry.createType('bool', true).toHex());
+        }
+        if (meta.query.parachainStaking) {
+            layer.set(compactHex(meta.query.parachainStaking.selectedCandidates()), meta.registry.createType(`Vec<${accountType}>`, [
+                alice
+            ]).toHex());
+        }
         return [
             new GenericExtrinsic(meta.registry, meta.tx.authorInherent.kickOffAuthorshipValidation()).toHex()
         ];

package/dist/esm/blockchain/inherent/parachain/validation-data.d.ts

@@ -1,7 +1,7 @@
 import { HexString } from '@polkadot/util/types';
 import { Block } from '../../block.js';
 import { BuildBlockParams, DownwardMessage, HorizontalMessage } from '../../txpool.js';
-import { CreateInherents } from '../index.js';
+import { InherentProvider } from '../index.js';
 export type ValidationData = {
     downwardMessages: DownwardMessage[];
     horizontalMessages: Record<number, HorizontalMessage[]>;
@@ -14,6 +14,6 @@ export type ValidationData = {
         trieNodes: HexString[];
     };
 };
-export declare class SetValidationData implements CreateInherents {
-    createInherents(parent: Block, params: BuildBlockParams): Promise<HexString[]>;
+export declare class SetValidationData implements InherentProvider {
+    createInherents(newBlock: Block, params: BuildBlockParams): Promise<HexString[]>;
 }

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

@@ -57,7 +57,9 @@ const getValidationData = async (parent)=>{
     return meta.registry.createType('GenericExtrinsic', validationDataExtrinsic).args[0].toJSON();
 };
 export class SetValidationData {
-    async createInherents(parent, params) {
+    async createInherents(newBlock, params) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
         const meta = await parent.meta;
         if (!meta.tx.parachainSystem?.setValidationData) {
             return [];

package/dist/esm/blockchain/inherent/timestamp.d.ts

@@ -0,0 +1,6 @@
+import { Block } from '../block.js';
+import { HexString } from '@polkadot/util/types';
+import { InherentProvider } from './index.js';
+export declare class SetTimestamp implements InherentProvider {
+    createInherents(newBlock: Block): Promise<HexString[]>;
+}

package/dist/esm/blockchain/inherent/timestamp.js

@@ -0,0 +1,14 @@
+import { GenericExtrinsic } from '@polkadot/types';
+import { getCurrentTimestamp, getSlotDuration } from '../../utils/index.js';
+export class SetTimestamp {
+    async createInherents(newBlock) {
+        const parent = await newBlock.parentBlock;
+        if (!parent) throw new Error('parent block not found');
+        const meta = await parent.meta;
+        const slotDuration = await getSlotDuration(parent.chain);
+        const currentTimestamp = await getCurrentTimestamp(parent.chain);
+        return [
+            new GenericExtrinsic(meta.registry, meta.tx.timestamp.set(currentTimestamp + BigInt(slotDuration))).toHex()
+        ];
+    }
+}

package/dist/esm/blockchain/txpool.d.ts

@@ -29,7 +29,7 @@ export interface BuildBlockParams {
 export declare class TxPool {
     #private;
     readonly event: EventEmitter<string | symbol, any>;
-    constructor(chain: Blockchain, inherentProvider: InherentProvider, mode?: BuildBlockMode);
+    constructor(chain: Blockchain, inherentProviders: InherentProvider[], mode?: BuildBlockMode);
     get pendingExtrinsics(): HexString[];
     get ump(): Record<number, HexString[]>;
     get dmp(): DownwardMessage[];

package/dist/esm/blockchain/txpool.js

@@ -20,14 +20,14 @@ export class TxPool {
     #dmp = [];
     #hrmp = {};
     #mode;
-    #inherentProvider;
+    #inherentProviders;
     #pendingBlocks = [];
     event = new EventEmitter();
     #isBuilding = false;
-    constructor(chain, inherentProvider, mode = "Batch"){
+    constructor(chain, inherentProviders, mode = "Batch"){
         this.#chain = chain;
         this.#mode = mode;
-        this.#inherentProvider = inherentProvider;
+        this.#inherentProviders = inherentProviders;
     }
     get pendingExtrinsics() {
         return this.#pool.map(({ extrinsic })=>extrinsic);
@@ -189,9 +189,7 @@ export class TxPool {
         logger.trace({
             params
         }, 'build block');
-        const head = this.#chain.head;
-        const inherents = await this.#inherentProvider.createInherents(head, params);
-        const [newBlock, pendingExtrinsics] = await buildBlock(head, inherents, params.transactions, params.upwardMessages, {
+        const [newBlock, pendingExtrinsics] = await buildBlock(this.#chain.head, this.#inherentProviders, params, {
             onApplyExtrinsicError: (extrinsic, error)=>{
                 this.event.emit(APPLY_EXTRINSIC_ERROR, [
                     extrinsic,
@@ -210,7 +208,7 @@ export class TxPool {
                         logger.trace(truncate(resp.storageDiff), `Apply extrinsic ${phase}`);
                 }
             } : undefined
-        }, params.unsafeBlockHeight);
+        });
         for (const extrinsic of pendingExtrinsics){
             this.#pool.push({
                 extrinsic,

package/dist/esm/logger.js

@@ -1,8 +1,14 @@
 import { pino } from 'pino';
+const level = typeof process === 'object' && process.env.LOG_LEVEL || 'info';
+const hideObject = typeof process === 'object' && !!process.env.LOG_COMPACT || false;
 export const pinoLogger = pino({
-    level: typeof process === 'object' && process.env.LOG_LEVEL || 'info',
+    level,
     transport: {
-        target: 'pino-pretty'
+        target: 'pino-pretty',
+        options: {
+            ignore: 'pid,hostname',
+            hideObject
+        }
     }
 });
 export const defaultLogger = pinoLogger.child({

package/dist/esm/setup.js

@@ -3,9 +3,9 @@ import { HttpProvider, WsProvider } from '@polkadot/rpc-provider';
 import { compactAddLength } from '@polkadot/util';
 import { Api } from './api.js';
 import { Blockchain } from './blockchain/index.js';
-import { InherentProviders, ParaInherentEnter, SetBabeRandomness, SetNimbusAuthorInherent, SetTimestamp, SetValidationData } from './blockchain/inherent/index.js';
 import { defaultLogger } from './logger.js';
 import { getSlotDuration, setStorage } from './index.js';
+import { inherentProviders } from './blockchain/inherent/index.js';
 export const genesisSetup = async (chain, genesis)=>{
     const meta = await chain.head.meta;
     const timestamp = Date.now();
@@ -86,16 +86,10 @@ export const setup = async (options)=>{
     if (!header) {
         throw new Error(`Cannot find header for ${blockHash}`);
     }
-    const inherents = new InherentProviders(new SetTimestamp(), [
-        new SetValidationData(),
-        new ParaInherentEnter(),
-        new SetNimbusAuthorInherent(),
-        new SetBabeRandomness()
-    ]);
     const chain = new Blockchain({
         api,
         buildBlockMode: options.buildBlockMode,
-        inherentProvider: inherents,
+        inherentProviders,
         db: options.db,
         header: {
             hash: blockHash,

package/dist/esm/utils/decoder.js

@@ -5,7 +5,7 @@ import _ from 'lodash';
 import { decodeWellKnownKey } from './well-known-keys.js';
 import { defaultLogger } from '../logger.js';
 const logger = defaultLogger.child({
-    module: 'decoder'
+    name: 'decoder'
 });
 const _CACHE = new LRUCache({
     max: 20 /* max 20 registries */ 

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

@@ -23,3 +23,6 @@ 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 getCurrentSlot: (chain: Blockchain) => Promise<number>;
+export declare const getCurrentTimestamp: (chain: Blockchain) => Promise<bigint>;
+export declare const getSlotDuration: (chain: Blockchain) => Promise<number>;

package/dist/esm/utils/index.js

@@ -1,4 +1,5 @@
-import { compactStripLength, u8aToHex } from '@polkadot/util';
+import { compactStripLength, hexToU8a, u8aToHex } from '@polkadot/util';
+import { getAuraSlotDuration } from '../wasm-executor/index.js';
 import { hexAddPrefix, hexStripPrefix } from '@polkadot/util/hex';
 export * from './set-storage.js';
 export * from './time-travel.js';
@@ -81,3 +82,28 @@ export const stripChildPrefix = (key)=>{
     if (!child) return key;
     return storageKey;
 };
+// use raw key here because some chain did not expose those storage to metadata
+const POTENTIAL_SLOT_KEYS = [
+    '0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed',
+    '0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed',
+    '0xab2a8d5eca218f218c6fda6b1d22bb926bc171ab77f6a731a6e80c34ee1eda19'
+];
+export const getCurrentSlot = async (chain)=>{
+    const meta = await chain.head.meta;
+    for (const key of POTENTIAL_SLOT_KEYS){
+        const slotRaw = await chain.head.get(key);
+        if (slotRaw) {
+            return meta.registry.createType('Slot', hexToU8a(slotRaw)).toNumber();
+        }
+    }
+    throw new Error('Cannot find current slot');
+};
+export const getCurrentTimestamp = async (chain)=>{
+    const meta = await chain.head.meta;
+    const timestamp = await chain.head.read('u64', meta.query.timestamp.now);
+    return timestamp?.toBigInt() ?? 0n;
+};
+export const getSlotDuration = async (chain)=>{
+    const meta = await chain.head.meta;
+    return meta.consts.babe ? meta.consts.babe.expectedBlockTime.toNumber() : meta.query.aura ? getAuraSlotDuration(await chain.head.wasm) : 12_000;
+};

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

@@ -1,5 +1,2 @@
 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/time-travel.js

@@ -1,25 +1,6 @@
-import { hexToU8a, u8aToHex } from '@polkadot/util';
-import { compactHex } from './index.js';
-import { getAuraSlotDuration } from '../wasm-executor/index.js';
+import { u8aToHex } from '@polkadot/util';
+import { compactHex, getSlotDuration } from './index.js';
 import { setStorage } from './set-storage.js';
-export const getCurrentSlot = async (chain)=>{
-    const meta = await chain.head.meta;
-    // use raw key here because some chain did not expose those storage to metadata
-    const slotRaw = meta.consts.babe ? await chain.head.get('0x1cb6f36e027abb2091cfb5110ab5087f06155b3cd9a8c9e5e9a23fd5dc13a5ed') // babe.currentSlot
-     : await chain.head.get('0x57f8dc2f5ab09467896f47300f04243806155b3cd9a8c9e5e9a23fd5dc13a5ed') // aura.currentSlot
-    ;
-    if (!slotRaw) throw new Error('Cannot find current slot');
-    return meta.registry.createType('Slot', hexToU8a(slotRaw)).toNumber();
-};
-export const getCurrentTimestamp = async (chain)=>{
-    const meta = await chain.head.meta;
-    const timestamp = await chain.head.read('u64', meta.query.timestamp.now);
-    return timestamp?.toBigInt() ?? 0n;
-};
-export const getSlotDuration = async (chain)=>{
-    const meta = await chain.head.meta;
-    return meta.consts.babe ? meta.consts.babe.expectedBlockTime.toNumber() : meta.query.aura ? getAuraSlotDuration(await chain.head.wasm) : 12_000;
-};
 export const timeTravel = async (chain, timestamp)=>{
     const meta = await chain.head.meta;
     const slotDuration = await getSlotDuration(chain);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.9.8-1",
+  "version": "0.9.8-2",
   "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.8-1",
+    "@acala-network/chopsticks-executor": "0.9.8-2",
     "@polkadot/rpc-provider": "^10.11.2",
     "@polkadot/types": "^10.11.2",
     "@polkadot/types-codec": "^10.11.2",