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

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

@@ -80,7 +80,7 @@ class SetValidationData {
             return [];
         }
         const extrinsic = await getValidationData(parent);
-        const newEntries = [];
+        let newEntries = [];
         const downwardMessages = [];
         const horizontalMessages = {};
         const paraId = await (0, _index.getParaId)(parent.chain);
@@ -229,6 +229,18 @@ 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 (0, _index1.createProof)(extrinsic.relayChainState.trieNodes, newEntries);
         const newData = {
             ...extrinsic,

package/dist/cjs/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/cjs/blockchain/txpool.js

@@ -193,6 +193,7 @@ class TxPool {
             ..._class_private_field_get(this, _hrmp)
         };
         const unsafeBlockHeight = params?.unsafeBlockHeight;
+        const relayChainStateOverrides = params?.relayChainStateOverrides;
         if (!params?.upwardMessages) {
             for (const id of Object.keys(_class_private_field_get(this, _ump))){
                 delete _class_private_field_get(this, _ump)[id];
@@ -209,7 +210,8 @@ class TxPool {
                 upwardMessages,
                 downwardMessages,
                 horizontalMessages,
-                unsafeBlockHeight
+                unsafeBlockHeight,
+                relayChainStateOverrides
             });
             // with the latest message queue, messages could be processed in the upcoming block
             if (!_class_private_field_get(this, _chain).processQueuedMessages) return;

package/dist/cjs/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/cjs/rpc/dev/new-block.js

@@ -27,10 +27,17 @@ const schema = _zod.z.object({
         data: _shared.zHex
     })).min(1)).optional(),
     transactions: _zod.z.array(_shared.zHex).min(1).optional(),
-    unsafeBlockHeight: _zod.z.number().optional()
+    unsafeBlockHeight: _zod.z.number().optional(),
+    relayChainStateOverrides: _zod.z.array(_zod.z.tuple([
+        _shared.zHex,
+        _zod.z.union([
+            _shared.zHex,
+            _zod.z.null()
+        ])
+    ])).optional()
 });
 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;
@@ -44,7 +51,8 @@ const dev_newBlock = async (context, [params])=>{
             horizontalMessages: hrmp,
             upwardMessages: ump,
             downwardMessages: dmp,
-            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined
+            unsafeBlockHeight: i === 0 ? unsafeBlockHeight : undefined,
+            relayChainStateOverrides: relayChainStateOverrides
         }).catch((error)=>{
             throw new _shared.ResponseError(1, error.toString());
         });

package/dist/cjs/rpc/index.js

@@ -19,11 +19,12 @@ _export(exports, {
         return _index.default;
     },
     substrate: function() {
-        return _index1.default;
+        return _index2.default;
     }
 });
 const _index = /*#__PURE__*/ _interop_require_default(require("./dev/index.js"));
-const _index1 = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
+const _index1 = /*#__PURE__*/ _interop_require_default(require("./rpc-spec/index.js"));
+const _index2 = /*#__PURE__*/ _interop_require_default(require("./substrate/index.js"));
 const _shared = require("./shared.js");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
@@ -31,6 +32,7 @@ function _interop_require_default(obj) {
     };
 }
 const allHandlers = {
+    ..._index2.default,
     ..._index1.default,
     ..._index.default,
     rpc_methods: async ()=>Promise.resolve({

package/dist/cjs/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/cjs/rpc/rpc-spec/chainHead_v1.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    chainHead_v1_body: function() {
+        return chainHead_v1_body;
+    },
+    chainHead_v1_call: function() {
+        return chainHead_v1_call;
+    },
+    chainHead_v1_continue: function() {
+        return chainHead_v1_continue;
+    },
+    chainHead_v1_follow: function() {
+        return chainHead_v1_follow;
+    },
+    chainHead_v1_header: function() {
+        return chainHead_v1_header;
+    },
+    chainHead_v1_stopOperation: function() {
+        return chainHead_v1_stopOperation;
+    },
+    chainHead_v1_storage: function() {
+        return chainHead_v1_storage;
+    },
+    chainHead_v1_unfollow: function() {
+        return chainHead_v1_unfollow;
+    },
+    chainHead_v1_unpin: function() {
+        return chainHead_v1_unpin;
+    }
+});
+const _shared = require("../shared.js");
+const _logger = require("../../logger.js");
+const logger = _logger.defaultLogger.child({
+    name: 'rpc-chainHead_v1'
+});
+const callbacks = new Map();
+async function afterResponse(fn) {
+    await new Promise((resolve)=>setTimeout(resolve, 0));
+    fn();
+}
+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;
+};
+const chainHead_v1_unfollow = async (_, [followSubscription], { unsubscribe })=>{
+    unsubscribe(followSubscription);
+    return null;
+};
+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);
+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);
+};
+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'
+};
+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 _shared.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);
+};
+const chainHead_v1_continue = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+const chainHead_v1_stopOperation = async (_context, [_followSubscription, _operationId])=>{
+    return null;
+};
+const chainHead_v1_unpin = async (_context, [_followSubscription, _hashOrHashes])=>{
+    return null;
+};

package/dist/cjs/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/cjs/rpc/rpc-spec/chainSpec_v1.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    chainSpec_v1_chainName: function() {
+        return chainSpec_v1_chainName;
+    },
+    chainSpec_v1_genesisHash: function() {
+        return chainSpec_v1_genesisHash;
+    },
+    chainSpec_v1_properties: function() {
+        return chainSpec_v1_properties;
+    }
+});
+const _shared = require("../shared.js");
+const chainSpec_v1_chainName = async (context)=>{
+    return context.chain.api.getSystemChain();
+};
+const chainSpec_v1_genesisHash = async (context)=>{
+    const genesisHash = await context.chain.api.getBlockHash(0);
+    if (genesisHash === null) {
+        throw new _shared.ResponseError(1, 'Unexpected null genesis hash');
+    }
+    return genesisHash;
+};
+const chainSpec_v1_properties = async (context)=>{
+    return context.chain.api.getSystemProperties();
+};

package/dist/cjs/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/cjs/rpc/rpc-spec/index.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    ChainHeadV1RPC: function() {
+        return _chainHead_v1;
+    },
+    ChainSpecV1RPC: function() {
+        return _chainSpec_v1;
+    },
+    TransactionV1RPC: function() {
+        return _transaction_v1;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _chainHead_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./chainHead_v1.js"));
+const _chainSpec_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./chainSpec_v1.js"));
+const _transaction_v1 = /*#__PURE__*/ _interop_require_wildcard(require("./transaction_v1.js"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const handlers = {
+    ..._chainHead_v1,
+    ..._transaction_v1,
+    ..._chainSpec_v1
+};
+const _default = handlers;

package/dist/cjs/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/cjs/rpc/rpc-spec/transaction_v1.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    transaction_v1_broadcast: function() {
+        return transaction_v1_broadcast;
+    },
+    transaction_v1_stop: function() {
+        return transaction_v1_stop;
+    }
+});
+const _logger = require("../../logger.js");
+const logger = _logger.defaultLogger.child({
+    name: 'rpc-transaction_v1'
+});
+const randomId = ()=>Math.random().toString(36).substring(2);
+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();
+};
+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/cjs/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}`;