@acala-network/chopsticks-core 0.14.2-1 → 0.16.0

package/dist/cjs/utils/proof.js

@@ -29,6 +29,9 @@ _export(exports, {
     },
     upgradeGoAheadSignal: function() {
         return upgradeGoAheadSignal;
+    },
+    upgradeRestrictionSignal: function() {
+        return upgradeRestrictionSignal;
     }
 });
 const _util = require("@polkadot/util");
@@ -52,6 +55,10 @@ const upgradeGoAheadSignal = (paraId)=>{
     const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
     return hash(prefix, paraId.toU8a());
 };
+const upgradeRestrictionSignal = (paraId)=>{
+    const prefix = '0xcd710b30bd2eab0352ddcc26417aa194f27bbb460270642b5bcaf032ea04d56a';
+    return hash(prefix, paraId.toU8a());
+};
 const hrmpIngressChannelIndex = (paraId)=>{
     const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
     return hash(prefix, paraId.toU8a());

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

@@ -65,7 +65,7 @@ export class SetValidationData {
             return [];
         }
         const extrinsic = await getValidationData(parent);
-        const newEntries = [];
+        let newEntries = [];
         const downwardMessages = [];
         const horizontalMessages = {};
         const paraId = await getParaId(parent.chain);
@@ -214,6 +214,18 @@ export class SetValidationData {
                 null
             ]);
         }
+        // Apply relay chain state overrides
+        if (params.relayChainStateOverrides) {
+            for (const [key, value] of params.relayChainStateOverrides){
+                // Remove any entry that matches the key being overridden
+                newEntries = newEntries.filter(([k, _])=>k != key);
+                // Push override
+                newEntries.push([
+                    key,
+                    value
+                ]);
+            }
+        }
         const { trieRootHash, nodes } = await createProof(extrinsic.relayChainState.trieNodes, newEntries);
         const newData = {
             ...extrinsic,

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

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

package/dist/esm/blockchain/txpool.js

@@ -138,6 +138,7 @@ export class TxPool {
             ...this.#hrmp
         };
         const unsafeBlockHeight = params?.unsafeBlockHeight;
+        const relayChainStateOverrides = params?.relayChainStateOverrides;
         if (!params?.upwardMessages) {
             for (const id of Object.keys(this.#ump)){
                 delete this.#ump[id];
@@ -154,7 +155,8 @@ export class TxPool {
                 upwardMessages,
                 downwardMessages,
                 horizontalMessages,
-                unsafeBlockHeight
+                unsafeBlockHeight,
+                relayChainStateOverrides
             });
             // with the latest message queue, messages could be processed in the upcoming block
             if (!this.#chain.processQueuedMessages) return;

package/dist/esm/rpc/dev/new-block.d.ts

@@ -26,6 +26,7 @@ declare const schema: z.ZodObject<{
     }>, "many">>>;
     transactions: z.ZodOptional<z.ZodArray<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, "many">>;
     unsafeBlockHeight: z.ZodOptional<z.ZodNumber>;
+    relayChainStateOverrides: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodUnion<[z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodNull]>], null>, "many">>;
 }, "strip", z.ZodTypeAny, {
     transactions?: `0x${string}`[] | undefined;
     unsafeBlockHeight?: number | undefined;
@@ -38,6 +39,7 @@ declare const schema: z.ZodObject<{
         data: `0x${string}`;
         sentAt: number;
     }[]> | undefined;
+    relayChainStateOverrides?: [`0x${string}`, `0x${string}` | null][] | undefined;
     count?: number | undefined;
     to?: number | undefined;
 }, {
@@ -52,6 +54,7 @@ declare const schema: z.ZodObject<{
         data: `0x${string}`;
         sentAt: number;
     }[]> | undefined;
+    relayChainStateOverrides?: [`0x${string}`, `0x${string}` | null][] | undefined;
     count?: number | undefined;
     to?: number | undefined;
 }>;
@@ -85,6 +88,10 @@ export interface NewBlockParams {
      * Build block using a specific block height (unsafe)
      */
     unsafeBlockHeight: Params['unsafeBlockHeight'];
+    /**
+     * Build block using a custom relay chain state
+     */
+    relayChainStateOverrides: Params['relayChainStateOverrides'];
 }
 /**
  * Build new blocks.

package/dist/esm/rpc/dev/new-block.js

@@ -17,7 +17,14 @@ const schema = z.object({
         data: zHex
     })).min(1)).optional(),
     transactions: z.array(zHex).min(1).optional(),
-    unsafeBlockHeight: z.number().optional()
+    unsafeBlockHeight: z.number().optional(),
+    relayChainStateOverrides: z.array(z.tuple([
+        zHex,
+        z.union([
+            zHex,
+            z.null()
+        ])
+    ])).optional()
 });
 /**
  * Build new blocks.
@@ -57,7 +64,7 @@ const schema = z.object({
  * await ws.send('dev_newBlock', [{ count: 2, unsafeBlockHeight: 100000001 }])
  * ```
  */ export const dev_newBlock = async (context, [params])=>{
-    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight } = schema.parse(params || {});
+    const { count, to, hrmp, ump, dmp, transactions, unsafeBlockHeight, relayChainStateOverrides } = schema.parse(params || {});
     const now = context.chain.head.number;
     const diff = to ? to - now : count;
     const finalCount = diff !== undefined ? Math.max(diff, 1) : 1;
@@ -71,7 +78,8 @@ const schema = z.object({
             horizontalMessages: hrmp,
             upwardMessages: ump,
             downwardMessages: dmp,
-            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined,
+            relayChainStateOverrides: relayChainStateOverrides
         }).catch((error)=>{
             throw new ResponseError(1, error.toString());
         });

package/dist/esm/rpc/index.js

@@ -1,7 +1,9 @@
 import dev from './dev/index.js';
+import rpcSpec from './rpc-spec/index.js';
 import substrate from './substrate/index.js';
 export const allHandlers = {
     ...substrate,
+    ...rpcSpec,
     ...dev,
     rpc_methods: async ()=>Promise.resolve({
             version: 1,

package/dist/esm/rpc/rpc-spec/chainHead_v1.d.ts

@@ -0,0 +1,79 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Start a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`withRuntime`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */
+export declare const chainHead_v1_follow: Handler<[boolean], string>;
+/**
+ * Stop a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`followSubscription`]
+ * @param subscriptionManager
+ */
+export declare const chainHead_v1_unfollow: Handler<[string], null>;
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return SCALE-encoded header, or null if the block is not found.
+ */
+export declare const chainHead_v1_header: Handler<[string, HexString], HexString | null>;
+type OperationStarted = {
+    result: 'started';
+    operationId: string;
+};
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `function`, `callParameters`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_call: Handler<[string, HexString, string, HexString], OperationStarted>;
+export type StorageStarted = OperationStarted & {
+    discardedItems: number;
+};
+export interface StorageItemRequest {
+    key: HexString;
+    type: 'value' | 'hash' | 'closestDescendantMerkleValue' | 'descendantsValues' | 'descendantsHashes';
+}
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `items`, `childTrie`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_storage: Handler<[
+    string,
+    HexString,
+    StorageItemRequest[],
+    HexString | null
+], StorageStarted>;
+export type LimitReached = {
+    result: 'limitReached';
+};
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */
+export declare const chainHead_v1_body: Handler<[string, HexString], OperationStarted | LimitReached>;
+export declare const chainHead_v1_continue: Handler<[string, HexString], null>;
+export declare const chainHead_v1_stopOperation: Handler<[string, HexString], null>;
+export declare const chainHead_v1_unpin: Handler<[string, HexString | HexString[]], null>;
+export {};

package/dist/esm/rpc/rpc-spec/chainHead_v1.js

@@ -0,0 +1,250 @@
+import { ResponseError } from '../shared.js';
+import { defaultLogger } from '../../logger.js';
+const logger = defaultLogger.child({
+    name: 'rpc-chainHead_v1'
+});
+const callbacks = new Map();
+async function afterResponse(fn) {
+    await new Promise((resolve)=>setTimeout(resolve, 0));
+    fn();
+}
+/**
+ * Start a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`withRuntime`]
+ * @param subscriptionManager
+ *
+ * @return subscription id
+ */ export const chainHead_v1_follow = async (context, [withRuntime], { subscribe })=>{
+    const update = async (block)=>{
+        logger.trace({
+            hash: block.hash
+        }, 'chainHead_v1_follow');
+        const getNewRuntime = async ()=>{
+            const [runtime, previousRuntime] = await Promise.all([
+                block.runtimeVersion,
+                block.parentBlock.then((b)=>b?.runtimeVersion)
+            ]);
+            const hasNewRuntime = runtime.implVersion !== previousRuntime?.implVersion || runtime.specVersion !== previousRuntime.specVersion;
+            return hasNewRuntime ? runtime : null;
+        };
+        const newRuntime = withRuntime ? await getNewRuntime() : null;
+        callback({
+            event: 'newBlock',
+            blockHash: block.hash,
+            parentBlockHash: (await block.parentBlock)?.hash,
+            newRuntime
+        });
+        callback({
+            event: 'bestBlockChanged',
+            bestBlockHash: block.hash
+        });
+        callback({
+            event: 'finalized',
+            finalizedBlockHashes: [
+                block.hash
+            ],
+            prunedBlockHashes: []
+        });
+    };
+    const id = context.chain.headState.subscribeHead(update);
+    const cleanup = ()=>{
+        context.chain.headState.unsubscribeHead(id);
+        callbacks.delete(id);
+    };
+    const callback = subscribe('chainHead_v1_followEvent', id, cleanup);
+    callbacks.set(id, callback);
+    afterResponse(async ()=>{
+        callback({
+            event: 'initialized',
+            finalizedBlockHashes: [
+                context.chain.head.hash
+            ],
+            finalizedBlockRuntime: withRuntime ? await context.chain.head.runtimeVersion : null
+        });
+    });
+    return id;
+};
+/**
+ * Stop a chainHead follow subscription
+ *
+ * @param context
+ * @param params - [`followSubscription`]
+ * @param subscriptionManager
+ */ export const chainHead_v1_unfollow = async (_, [followSubscription], { unsubscribe })=>{
+    unsubscribe(followSubscription);
+    return null;
+};
+/**
+ * Retrieve the header for a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return SCALE-encoded header, or null if the block is not found.
+ */ export const chainHead_v1_header = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return null;
+    const block = await context.chain.getBlock(hash);
+    return block ? (await block.header).toHex() : null;
+};
+const operationStarted = (operationId)=>({
+        result: 'started',
+        operationId
+    });
+const randomId = ()=>Math.random().toString(36).substring(2);
+/**
+ * Perform a runtime call for a block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `function`, `callParameters`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_call = async (context, [followSubscription, hash, method, callParameters])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: `Block ${hash} not found`
+            });
+        } else {
+            try {
+                const resp = await block.call(method, [
+                    callParameters
+                ]);
+                callbacks.get(followSubscription)?.({
+                    event: 'operationCallDone',
+                    operationId,
+                    output: resp.result
+                });
+            } catch (ex) {
+                callbacks.get(followSubscription)?.({
+                    event: 'operationError',
+                    operationId,
+                    error: ex.message
+                });
+            }
+        }
+    });
+    return operationStarted(operationId);
+};
+/**
+ * Query the storage for a given block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`, `items`, `childTrie`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_storage = async (context, [followSubscription, hash, items, _childTrie])=>{
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const block = await context.chain.getBlock(hash);
+        if (!block) {
+            callbacks.get(followSubscription)?.({
+                event: 'operationError',
+                operationId,
+                error: 'Block not found'
+            });
+            return;
+        }
+        const handleStorageItemRequest = async (sir)=>{
+            switch(sir.type){
+                case 'value':
+                    {
+                        const value = await block.get(sir.key);
+                        if (value) {
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items: [
+                                    {
+                                        key: sir.key,
+                                        value
+                                    }
+                                ]
+                            });
+                        }
+                        break;
+                    }
+                case 'descendantsValues':
+                    {
+                        // TODO expose pagination
+                        const pageSize = 100;
+                        let startKey = '0x';
+                        while(startKey){
+                            const keys = await block.getKeysPaged({
+                                prefix: sir.key,
+                                pageSize,
+                                startKey
+                            });
+                            startKey = keys[pageSize - 1] ?? null;
+                            const items = await Promise.all(keys.map((key)=>block.get(key).then((value)=>({
+                                        key,
+                                        value
+                                    }))));
+                            callbacks.get(followSubscription)?.({
+                                event: 'operationStorageItems',
+                                operationId,
+                                items
+                            });
+                            break;
+                        }
+                        break;
+                    }
+                default:
+                    // TODO
+                    console.warn(`Storage type not implemented ${sir.type}`);
+            }
+        };
+        await Promise.all(items.map(handleStorageItemRequest));
+        callbacks.get(followSubscription)?.({
+            event: 'operationStorageDone',
+            operationId
+        });
+    });
+    return {
+        ...operationStarted(operationId),
+        discardedItems: 0
+    };
+};
+const limitReached = {
+    result: 'limitReached'
+};
+/**
+ * Retrieve the body of a specific block
+ *
+ * @param context
+ * @param params - [`followSubscription`, `hash`]
+ *
+ * @return OperationStarted event with operationId to receive the result on the follow subscription
+ */ export const chainHead_v1_body = async (context, [followSubscription, hash])=>{
+    if (!callbacks.has(followSubscription)) return limitReached;
+    const block = await context.chain.getBlock(hash);
+    if (!block) {
+        throw new ResponseError(-32801, 'Block not found');
+    }
+    const operationId = randomId();
+    afterResponse(async ()=>{
+        const body = await block.extrinsics;
+        callbacks.get(followSubscription)?.({
+            event: 'operationBodyDone',
+            operationId,
+            value: body
+        });
+    });
+    return operationStarted(operationId);
+};
+// Currently no-ops, will come into play when pagination is implemented
+export const chainHead_v1_continue = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+export const chainHead_v1_stopOperation = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+// no-op, since there's no concept of unpinning in chopsticks
+export const chainHead_v1_unpin = async (_context, [_followSubscription, _hashOrHashes])=>{
+    return null;
+};

package/dist/esm/rpc/rpc-spec/chainSpec_v1.d.ts

@@ -0,0 +1,6 @@
+import { ChainProperties } from '../../index.js';
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+export declare const chainSpec_v1_chainName: Handler<[], string>;
+export declare const chainSpec_v1_genesisHash: Handler<[], HexString>;
+export declare const chainSpec_v1_properties: Handler<[], ChainProperties>;

package/dist/esm/rpc/rpc-spec/chainSpec_v1.js

@@ -0,0 +1,14 @@
+import { ResponseError } from '../shared.js';
+export const chainSpec_v1_chainName = async (context)=>{
+    return context.chain.api.getSystemChain();
+};
+export const chainSpec_v1_genesisHash = async (context)=>{
+    const genesisHash = await context.chain.api.getBlockHash(0);
+    if (genesisHash === null) {
+        throw new ResponseError(1, 'Unexpected null genesis hash');
+    }
+    return genesisHash;
+};
+export const chainSpec_v1_properties = async (context)=>{
+    return context.chain.api.getSystemProperties();
+};

package/dist/esm/rpc/rpc-spec/index.d.ts

@@ -0,0 +1,27 @@
+import * as ChainHeadV1RPC from './chainHead_v1.js';
+import * as ChainSpecV1RPC from './chainSpec_v1.js';
+import * as TransactionV1RPC from './transaction_v1.js';
+export { ChainHeadV1RPC, TransactionV1RPC, ChainSpecV1RPC };
+declare const handlers: {
+    chainSpec_v1_chainName: import("../shared.js").Handler<[], string>;
+    chainSpec_v1_genesisHash: import("../shared.js").Handler<[], import("@polkadot/util/types").HexString>;
+    chainSpec_v1_properties: import("../shared.js").Handler<[], import("../../index.js").ChainProperties>;
+    transaction_v1_broadcast: import("../shared.js").Handler<[import("@polkadot/util/types").HexString], string | null>;
+    transaction_v1_stop: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_follow: import("../shared.js").Handler<[boolean], string>;
+    chainHead_v1_unfollow: import("../shared.js").Handler<[string], null>;
+    chainHead_v1_header: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], import("@polkadot/util/types").HexString | null>;
+    chainHead_v1_call: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    }>;
+    chainHead_v1_storage: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString, ChainHeadV1RPC.StorageItemRequest[], import("@polkadot/util/types").HexString | null], ChainHeadV1RPC.StorageStarted>;
+    chainHead_v1_body: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], {
+        result: "started";
+        operationId: string;
+    } | ChainHeadV1RPC.LimitReached>;
+    chainHead_v1_continue: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
+    chainHead_v1_stopOperation: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString], null>;
+    chainHead_v1_unpin: import("../shared.js").Handler<[string, import("@polkadot/util/types").HexString | import("@polkadot/util/types").HexString[]], null>;
+};
+export default handlers;

package/dist/esm/rpc/rpc-spec/index.js

@@ -0,0 +1,10 @@
+import * as ChainHeadV1RPC from './chainHead_v1.js';
+import * as ChainSpecV1RPC from './chainSpec_v1.js';
+import * as TransactionV1RPC from './transaction_v1.js';
+export { ChainHeadV1RPC, TransactionV1RPC, ChainSpecV1RPC };
+const handlers = {
+    ...ChainHeadV1RPC,
+    ...TransactionV1RPC,
+    ...ChainSpecV1RPC
+};
+export default handlers;

package/dist/esm/rpc/rpc-spec/transaction_v1.d.ts

@@ -0,0 +1,16 @@
+import { Handler } from '../shared.js';
+import { HexString } from '@polkadot/util/types';
+/**
+ * Submit the extrinsic to the transaction pool
+ *
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return operation id
+ */
+export declare const transaction_v1_broadcast: Handler<[HexString], string | null>;
+/**
+ * Stop broadcasting the transaction to other nodes.
+ *
+ */
+export declare const transaction_v1_stop: Handler<[string], null>;

package/dist/esm/rpc/rpc-spec/transaction_v1.js

@@ -0,0 +1,27 @@
+import { defaultLogger } from '../../logger.js';
+const logger = defaultLogger.child({
+    name: 'rpc-transaction_v1'
+});
+const randomId = ()=>Math.random().toString(36).substring(2);
+/**
+ * Submit the extrinsic to the transaction pool
+ *
+ * @param context
+ * @param params - [`extrinsic`]
+ *
+ * @return operation id
+ */ export const transaction_v1_broadcast = async (context, [extrinsic])=>{
+    await context.chain.submitExtrinsic(extrinsic).catch((err)=>{
+        // As per the spec, the invalid transaction errors should be ignored.
+        logger.warn('Submit extrinsic failed', err);
+    });
+    return randomId();
+};
+/**
+ * Stop broadcasting the transaction to other nodes.
+ *
+ */ export const transaction_v1_stop = async (_context, [_operationId])=>{
+    // Chopsticks doesn't have any process to broadcast the transaction through P2P
+    // so stopping doesn't have any effect.
+    return null;
+};

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

@@ -11,6 +11,7 @@ export declare const WELL_KNOWN_KEYS: {
 };
 export declare const dmqMqcHead: (paraId: u32) => `0x${string}`;
 export declare const upgradeGoAheadSignal: (paraId: u32) => `0x${string}`;
+export declare const upgradeRestrictionSignal: (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}`;

package/dist/esm/utils/proof.js

@@ -19,6 +19,10 @@ export const upgradeGoAheadSignal = (paraId)=>{
     const prefix = '0xcd710b30bd2eab0352ddcc26417aa1949e94c040f5e73d9b7addd6cb603d15d3';
     return hash(prefix, paraId.toU8a());
 };
+export const upgradeRestrictionSignal = (paraId)=>{
+    const prefix = '0xcd710b30bd2eab0352ddcc26417aa194f27bbb460270642b5bcaf032ea04d56a';
+    return hash(prefix, paraId.toU8a());
+};
 export const hrmpIngressChannelIndex = (paraId)=>{
     const prefix = '0x6a0da05ca59913bc38a8630590f2627c1d3719f5b0b12c7105c073c507445948';
     return hash(prefix, paraId.toU8a());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acala-network/chopsticks-core",
-  "version": "0.14.2-1",
+  "version": "0.16.0",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
@@ -11,7 +11,7 @@
     "depcheck": "npx depcheck"
   },
   "dependencies": {
-    "@acala-network/chopsticks-executor": "0.14.2-1",
+    "@acala-network/chopsticks-executor": "0.16.0",
     "@polkadot/rpc-provider": "^12.3.1",
     "@polkadot/types": "^12.3.1",
     "@polkadot/types-codec": "^12.3.1",