@acala-network/chopsticks-utils 1.0.2-1 → 1.0.2-2

package/dist/cjs/index.d.ts

@@ -7,76 +7,150 @@ import { Keyring } from '@polkadot/keyring';
 import { NewBlockParams } from '@acala-network/chopsticks-core/rpc/dev/new-block.js';
 import { SubmittableExtrinsic } from '@polkadot/api-base/types';
 export * from './signFake.js';
+/**
+ * Configuration options for setting up a blockchain network instance
+ */
 export type SetupOption = {
+    /** WebSocket endpoint(s) for connecting to the network */
     endpoint: string | string[];
+    /** Specific block number to start from */
     blockNumber?: number;
+    /** Specific block hash to start from */
     blockHash?: HexString;
+    /** Path to override WASM runtime */
     wasmOverride?: string;
+    /** Path to database file */
     db?: string;
+    /** Connection timeout in milliseconds */
     timeout?: number;
+    /** Host address to bind the server to */
     host?: string;
+    /** Port number to bind the server to */
     port?: number;
+    /** Maximum number of blocks to keep in memory */
     maxMemoryBlockCount?: number;
+    /** Resume from a previous state (block hash or number) */
     resume?: boolean | HexString | number;
+    /** Runtime log level (0-5) */
     runtimeLogLevel?: number;
+    /** Allow unresolved imports in runtime */
     allowUnresolvedImports?: boolean;
+    /** Process queued XCM messages */
     processQueuedMessages?: boolean;
 };
+/**
+ * Extended configuration type that includes timeout
+ */
 export type SetupConfig = Config & {
+    /** Connection timeout in milliseconds */
     timeout?: number;
 };
+/**
+ * Creates a configuration object from setup options
+ * @param options - Setup options for the network
+ * @returns Configuration object compatible with chopsticks
+ */
 export declare const createConfig: ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, host, port, maxMemoryBlockCount, resume, runtimeLogLevel, allowUnresolvedImports, processQueuedMessages, }: SetupOption) => SetupConfig;
+/**
+ * Sets up a blockchain network context using provided options
+ * @param option - Setup options for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */
 export declare const setupContext: (option: SetupOption) => Promise<{
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>;
+/**
+ * Sets up a blockchain network context using a configuration object
+ * @param config - Configuration object for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */
 export declare const setupContextWithConfig: ({ timeout, ...config }: SetupConfig) => Promise<{
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>;
+/** Type alias for the network context returned by setupContext */
 export type NetworkContext = Awaited<ReturnType<typeof setupContext>>;
+/**
+ * Sets up multiple blockchain networks and establishes connections between them
+ * @param networkOptions - Configuration options for each network
+ * @returns Record of network contexts indexed by network name
+ */
 export declare const setupNetworks: (networkOptions: Partial<Record<string, Config | string | undefined>>) => Promise<Record<string, {
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>>;
+/**
+ * Creates a deferred promise that can be resolved or rejected from outside
+ * @returns Object containing promise, resolve function, and reject function
+ */
 export declare function defer<T>(): {
     resolve: (value: any) => void;
     reject: (reason: any) => void;
     promise: Promise<T>;
 };
+/**
+ * Sends a transaction and waits for it to be included in a block
+ * @param tx - Promise of a submittable extrinsic
+ * @returns Promise that resolves with transaction events
+ */
 export declare const sendTransaction: (tx: Promise<SubmittableExtrinsic<"promise">>) => Promise<{
     events: Promise<Codec[]>;
 }>;
+/**
+ * Creates a set of test keypairs for both ed25519/sr25519 and ethereum addresses
+ * @param keyringType - Type of keyring to use for substrate addresses ('ed25519' or 'sr25519')
+ * @param ss58Format - SS58 address format to use
+ * @returns Object containing various test keypairs and keyring instances
+ */
 export declare const testingPairs: (keyringType?: "ed25519" | "sr25519", ss58Format?: number) => {
     alice: import("@polkadot/keyring/types").KeyringPair;
     bob: import("@polkadot/keyring/types").KeyringPair;

package/dist/cjs/index.js

@@ -89,33 +89,33 @@ const setupContextWithConfig = async ({ timeout, ...config })=>{
         ws,
         api,
         dev: {
-            newBlock: (param)=>{
+            /** Creates a new block with optional parameters */ newBlock: (param)=>{
                 return ws.send('dev_newBlock', [
                     param
                 ]);
             },
-            setStorage: (values, blockHash)=>{
+            /** Sets storage values at a specific block */ setStorage: (values, blockHash)=>{
                 return ws.send('dev_setStorage', [
                     values,
                     blockHash
                 ]);
             },
-            timeTravel: (date)=>{
+            /** Moves blockchain time to a specific timestamp */ timeTravel: (date)=>{
                 return ws.send('dev_timeTravel', [
                     date
                 ]);
             },
-            setHead: (hashOrNumber)=>{
+            /** Sets the chain head to a specific block */ setHead: (hashOrNumber)=>{
                 return ws.send('dev_setHead', [
                     hashOrNumber
                 ]);
             }
         },
-        async teardown () {
+        /** Cleans up resources and closes connections */ async teardown () {
             await api.disconnect();
             await close();
         },
-        async pause () {
+        /** Pauses execution and enables manual interaction through Polkadot.js apps */ async pause () {
             await ws.send('dev_setBlockBuildMode', [
                 _chopsticks.BuildBlockMode.Instant
             ]);

package/dist/esm/index.d.ts

@@ -7,76 +7,150 @@ import { Keyring } from '@polkadot/keyring';
 import { NewBlockParams } from '@acala-network/chopsticks-core/rpc/dev/new-block.js';
 import { SubmittableExtrinsic } from '@polkadot/api-base/types';
 export * from './signFake.js';
+/**
+ * Configuration options for setting up a blockchain network instance
+ */
 export type SetupOption = {
+    /** WebSocket endpoint(s) for connecting to the network */
     endpoint: string | string[];
+    /** Specific block number to start from */
     blockNumber?: number;
+    /** Specific block hash to start from */
     blockHash?: HexString;
+    /** Path to override WASM runtime */
     wasmOverride?: string;
+    /** Path to database file */
     db?: string;
+    /** Connection timeout in milliseconds */
     timeout?: number;
+    /** Host address to bind the server to */
     host?: string;
+    /** Port number to bind the server to */
     port?: number;
+    /** Maximum number of blocks to keep in memory */
     maxMemoryBlockCount?: number;
+    /** Resume from a previous state (block hash or number) */
     resume?: boolean | HexString | number;
+    /** Runtime log level (0-5) */
     runtimeLogLevel?: number;
+    /** Allow unresolved imports in runtime */
     allowUnresolvedImports?: boolean;
+    /** Process queued XCM messages */
     processQueuedMessages?: boolean;
 };
+/**
+ * Extended configuration type that includes timeout
+ */
 export type SetupConfig = Config & {
+    /** Connection timeout in milliseconds */
     timeout?: number;
 };
+/**
+ * Creates a configuration object from setup options
+ * @param options - Setup options for the network
+ * @returns Configuration object compatible with chopsticks
+ */
 export declare const createConfig: ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, host, port, maxMemoryBlockCount, resume, runtimeLogLevel, allowUnresolvedImports, processQueuedMessages, }: SetupOption) => SetupConfig;
+/**
+ * Sets up a blockchain network context using provided options
+ * @param option - Setup options for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */
 export declare const setupContext: (option: SetupOption) => Promise<{
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>;
+/**
+ * Sets up a blockchain network context using a configuration object
+ * @param config - Configuration object for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */
 export declare const setupContextWithConfig: ({ timeout, ...config }: SetupConfig) => Promise<{
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>;
+/** Type alias for the network context returned by setupContext */
 export type NetworkContext = Awaited<ReturnType<typeof setupContext>>;
+/**
+ * Sets up multiple blockchain networks and establishes connections between them
+ * @param networkOptions - Configuration options for each network
+ * @returns Record of network contexts indexed by network name
+ */
 export declare const setupNetworks: (networkOptions: Partial<Record<string, Config | string | undefined>>) => Promise<Record<string, {
     url: string;
     chain: import("@acala-network/chopsticks").Blockchain;
     ws: WsProvider;
     api: ApiPromise;
     dev: {
+        /** Creates a new block with optional parameters */
         newBlock: (param?: Partial<NewBlockParams>) => Promise<string>;
+        /** Sets storage values at a specific block */
         setStorage: (values: StorageValues, blockHash?: string) => Promise<any>;
+        /** Moves blockchain time to a specific timestamp */
         timeTravel: (date: string | number) => Promise<number>;
+        /** Sets the chain head to a specific block */
         setHead: (hashOrNumber: string | number) => Promise<any>;
     };
+    /** Cleans up resources and closes connections */
     teardown(): Promise<void>;
+    /** Pauses execution and enables manual interaction through Polkadot.js apps */
     pause(): Promise<unknown>;
 }>>;
+/**
+ * Creates a deferred promise that can be resolved or rejected from outside
+ * @returns Object containing promise, resolve function, and reject function
+ */
 export declare function defer<T>(): {
     resolve: (value: any) => void;
     reject: (reason: any) => void;
     promise: Promise<T>;
 };
+/**
+ * Sends a transaction and waits for it to be included in a block
+ * @param tx - Promise of a submittable extrinsic
+ * @returns Promise that resolves with transaction events
+ */
 export declare const sendTransaction: (tx: Promise<SubmittableExtrinsic<"promise">>) => Promise<{
     events: Promise<Codec[]>;
 }>;
+/**
+ * Creates a set of test keypairs for both ed25519/sr25519 and ethereum addresses
+ * @param keyringType - Type of keyring to use for substrate addresses ('ed25519' or 'sr25519')
+ * @param ss58Format - SS58 address format to use
+ * @returns Object containing various test keypairs and keyring instances
+ */
 export declare const testingPairs: (keyringType?: "ed25519" | "sr25519", ss58Format?: number) => {
     alice: import("@polkadot/keyring/types").KeyringPair;
     bob: import("@polkadot/keyring/types").KeyringPair;

package/dist/esm/index.js

@@ -5,7 +5,11 @@ const logger = defaultLogger.child({
     name: 'utils'
 });
 export * from './signFake.js';
-export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, host, port, maxMemoryBlockCount, resume, runtimeLogLevel, allowUnresolvedImports, processQueuedMessages })=>{
+/**
+ * Creates a configuration object from setup options
+ * @param options - Setup options for the network
+ * @returns Configuration object compatible with chopsticks
+ */ export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, db, timeout, host, port, maxMemoryBlockCount, resume, runtimeLogLevel, allowUnresolvedImports, processQueuedMessages })=>{
     // random port if not specified
     port = port ?? Math.floor(Math.random() * 10000) + 10000;
     const config = {
@@ -26,10 +30,18 @@ export const createConfig = ({ endpoint, blockNumber, blockHash, wasmOverride, d
     };
     return config;
 };
-export const setupContext = async (option)=>{
+/**
+ * Sets up a blockchain network context using provided options
+ * @param option - Setup options for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */ export const setupContext = async (option)=>{
     return setupContextWithConfig(createConfig(option));
 };
-export const setupContextWithConfig = async ({ timeout, ...config })=>{
+/**
+ * Sets up a blockchain network context using a configuration object
+ * @param config - Configuration object for the network
+ * @returns Network context including API, WebSocket provider, and utility functions
+ */ export const setupContextWithConfig = async ({ timeout, ...config })=>{
     const { chain, addr, close } = await setupWithServer(config);
     const url = `ws://${addr}`;
     const ws = new WsProvider(url, 3_000, undefined, timeout);
@@ -43,33 +55,33 @@ export const setupContextWithConfig = async ({ timeout, ...config })=>{
         ws,
         api,
         dev: {
-            newBlock: (param)=>{
+            /** Creates a new block with optional parameters */ newBlock: (param)=>{
                 return ws.send('dev_newBlock', [
                     param
                 ]);
             },
-            setStorage: (values, blockHash)=>{
+            /** Sets storage values at a specific block */ setStorage: (values, blockHash)=>{
                 return ws.send('dev_setStorage', [
                     values,
                     blockHash
                 ]);
             },
-            timeTravel: (date)=>{
+            /** Moves blockchain time to a specific timestamp */ timeTravel: (date)=>{
                 return ws.send('dev_timeTravel', [
                     date
                 ]);
             },
-            setHead: (hashOrNumber)=>{
+            /** Sets the chain head to a specific block */ setHead: (hashOrNumber)=>{
                 return ws.send('dev_setHead', [
                     hashOrNumber
                 ]);
             }
         },
-        async teardown () {
+        /** Cleans up resources and closes connections */ async teardown () {
             await api.disconnect();
             await close();
         },
-        async pause () {
+        /** Pauses execution and enables manual interaction through Polkadot.js apps */ async pause () {
             await ws.send('dev_setBlockBuildMode', [
                 BuildBlockMode.Instant
             ]);
@@ -80,7 +92,11 @@ export const setupContextWithConfig = async ({ timeout, ...config })=>{
         }
     };
 };
-export const setupNetworks = async (networkOptions)=>{
+/**
+ * Sets up multiple blockchain networks and establishes connections between them
+ * @param networkOptions - Configuration options for each network
+ * @returns Record of network contexts indexed by network name
+ */ export const setupNetworks = async (networkOptions)=>{
     const ret = {};
     let wasmOverriden = false;
     for (const [name, options] of Object.entries(networkOptions)){
@@ -114,7 +130,10 @@ export const setupNetworks = async (networkOptions)=>{
     }
     return ret;
 };
-export function defer() {
+/**
+ * Creates a deferred promise that can be resolved or rejected from outside
+ * @returns Object containing promise, resolve function, and reject function
+ */ export function defer() {
     const deferred = {};
     deferred.promise = new Promise((resolve, reject)=>{
         deferred.resolve = resolve;
@@ -122,7 +141,11 @@ export function defer() {
     });
     return deferred;
 }
-export const sendTransaction = async (tx)=>{
+/**
+ * Sends a transaction and waits for it to be included in a block
+ * @param tx - Promise of a submittable extrinsic
+ * @returns Promise that resolves with transaction events
+ */ export const sendTransaction = async (tx)=>{
     const signed = await tx;
     const deferred = defer();
     await signed.send((status)=>{
@@ -140,7 +163,12 @@ export const sendTransaction = async (tx)=>{
         events: deferred.promise
     };
 };
-export const testingPairs = (keyringType = 'ed25519', ss58Format)=>{
+/**
+ * Creates a set of test keypairs for both ed25519/sr25519 and ethereum addresses
+ * @param keyringType - Type of keyring to use for substrate addresses ('ed25519' or 'sr25519')
+ * @param ss58Format - SS58 address format to use
+ * @returns Object containing various test keypairs and keyring instances
+ */ export const testingPairs = (keyringType = 'ed25519', ss58Format)=>{
     const keyringEth = createTestKeyring({
         type: 'ethereum'
     });

package/package.json

@@ -1,27 +1,30 @@
 {
   "name": "@acala-network/chopsticks-utils",
-  "version": "1.0.2-1",
+  "version": "1.0.2-2",
   "author": "Acala Developers <hello@acala.network>",
   "license": "Apache-2.0",
   "type": "module",
+  "engines": {
+    "node": ">=v20"
+  },
   "scripts": {
     "clean": "rm -rf dist tsconfig.tsbuildinfo",
     "build": "yarn clean && ../../package-build.sh",
     "depcheck": "npx depcheck"
   },
   "dependencies": {
-    "@acala-network/chopsticks": "1.0.2-1",
-    "@acala-network/chopsticks-core": "1.0.2-1",
-    "@polkadot/api": "^14.0.1",
-    "@polkadot/api-base": "^14.0.1",
-    "@polkadot/keyring": "^13.2.2",
-    "@polkadot/types": "^14.0.1",
-    "@polkadot/util": "^13.2.2"
+    "@acala-network/chopsticks": "1.0.2-2",
+    "@acala-network/chopsticks-core": "1.0.2-2",
+    "@polkadot/api": "^15.0",
+    "@polkadot/api-base": "^15.0",
+    "@polkadot/keyring": "^13.2",
+    "@polkadot/types": "^15.0",
+    "@polkadot/util": "^13.2"
   },
   "devDependencies": {
-    "@swc/cli": "0.5.0",
-    "@swc/core": "^1.7.40",
-    "typescript": "^5.6.3"
+    "@swc/cli": "0.5.2",
+    "@swc/core": "^1.10.1",
+    "typescript": "^5.7.2"
   },
   "files": [
     "dist/esm/**",