@digicatapult/sqnc-process-management 2.2.128 → 2.2.129

package/README.md

@@ -200,14 +200,14 @@ Unit tests can be run without docker using:
 npm run test:unit
 ```
 
-To run the integration test suite first bring up the test dependency services using docker
+Running the integration test suite requires docker to be installed. Tests can then be executed with:
 
 ```shell
-docker compose -f ./docker-compose-test.yaml up -d
+npm run test
 ```
 
-And then to run the tests
+If you want to see output from the `sqnc-node` container brought up with `testcontainers` run:
 
 ```shell
-npm run test
+ DEBUG=testcontainers* npm run test
 ```

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@digicatapult/sqnc-process-management",
-    "version": "2.2.128",
+    "version": "2.2.129",
     "description": "SQNC Process Management Flow",
     "main": "./lib/index.js",
     "bin": {
@@ -51,6 +51,7 @@
         "mocha": "^10.8.2",
         "nodemon": "^3.1.7",
         "prettier": "^3.3.3",
+        "testcontainers": "^10.14.0",
         "ts-mocha": "^10.0.0",
         "ts-node": "^10.9.2"
     },

package/build/src/lib/process/api.d.ts

@@ -1,3 +1,4 @@
+export declare function resetLastSubmittedNonce(): void;
 export declare const createProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, program: Process.Program, options: Polkadot.Options) => Promise<{
     waitForFinal: Promise<Process.Payload>;
 }>;

package/build/src/lib/process/api.js

@@ -7,6 +7,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { ProgramError } from '../types/error.js';
 import * as api from '../utils/polkadot.js';
 import { hexToUtf8 } from './hex.js';
@@ -18,6 +70,10 @@ const isProgramValid = (program, out = { ops: 0, restrictions: -1 }) => {
     });
     return out.ops === out.restrictions;
 };
+let lastSubmittedNonce = -1;
+export function resetLastSubmittedNonce() {
+    lastSubmittedNonce = -1;
+}
 // TODO refactor since api.ts other should be a util
 // since createNodeApi, set's all routes we could use in process.index.ts
 export const createProcessTransaction = (polkadot, processId, program, options) => __awaiter(void 0, void 0, void 0, function* () {
@@ -32,9 +88,12 @@ export const createProcessTransaction = (polkadot, processId, program, options)
         reject = rej;
     });
     try {
+        const nextTxPoolNonce = (yield polkadot.api.rpc.system.accountNextIndex(sudo.publicKey)).toNumber();
+        const nonce = Math.max(nextTxPoolNonce, lastSubmittedNonce + 1);
+        lastSubmittedNonce = nonce;
         const unsub = yield polkadot.api.tx.sudo
             .sudo(polkadot.api.tx.processValidation.createProcess(processId, program))
-            .signAndSend(sudo, { nonce: -1 }, (result) => {
+            .signAndSend(sudo, { nonce }, (result) => {
             if (result.status.isFinalized) {
                 const { event } = result.events.find(({ event: { method } }) => method === 'ProcessCreated');
                 const data = event.data;
@@ -64,9 +123,12 @@ export const disableProcessTransaction = (polkadot, processId, version, options)
     const supportsManualSeal = !!polkadot.api.rpc.engine.createBlock;
     return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
         try {
+            const nextTxPoolNonce = (yield polkadot.api.rpc.system.accountNextIndex(sudo.publicKey)).toNumber();
+            const nonce = Math.max(nextTxPoolNonce, lastSubmittedNonce + 1);
+            lastSubmittedNonce = nonce;
             const unsub = yield polkadot.api.tx.sudo
                 .sudo(polkadot.api.tx.processValidation.disableProcess(processId, version))
-                .signAndSend(sudo, (result) => {
+                .signAndSend(sudo, { nonce }, (result) => {
                 if (result.status.isFinalized) {
                     const { event } = result.events.find(({ event: { method } }) => method === 'ProcessDisabled');
                     const data = event.data;
@@ -89,19 +151,31 @@ export const disableProcessTransaction = (polkadot, processId, version, options)
     }));
 });
 export const getAll = (options) => __awaiter(void 0, void 0, void 0, function* () {
-    const polkadot = yield api.createNodeApi(options);
-    const processesRaw = yield polkadot.api.query.processValidation.processModel.entries();
-    return processesRaw.map(([idRaw, data]) => {
-        const id = idRaw.toHuman();
-        return {
-            name: id[0],
-            version: parseInt(id[1]),
-            status: data.status.toString(),
-            program: data.program.toJSON(),
-            createdAtHash: data.createdAtHash.toHuman(),
-            initialU8aLength: data.initialU8aLength,
-        };
-    });
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const polkadot = __addDisposableResource(env_1, yield api.createNodeApi(options), true);
+        const processesRaw = yield polkadot.api.query.processValidation.processModel.entries();
+        return processesRaw.map(([idRaw, data]) => {
+            const id = idRaw.toHuman();
+            return {
+                name: id[0],
+                version: parseInt(id[1]),
+                status: data.status.toString(),
+                program: data.program.toJSON(),
+                createdAtHash: data.createdAtHash.toHuman(),
+                initialU8aLength: data.initialU8aLength,
+            };
+        });
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            yield result_1;
+    }
 });
 export const getVersion = (polkadot, processId) => __awaiter(void 0, void 0, void 0, function* () {
     const id = yield polkadot.api.query.processValidation.versionModel(processId);

package/build/src/lib/process/index.d.ts

@@ -5,7 +5,7 @@ export declare const sanitizeInput: (data: string) => Process.Result<{
 }[], CliInputParseError>;
 export declare const loadProcesses: ({ data, options, dryRun, verbose, }: {
     data: string;
-    options?: Polkadot.Options;
+    options: Polkadot.Options;
     dryRun?: boolean;
     verbose?: boolean;
 }) => Promise<Process.Response>;
@@ -16,7 +16,7 @@ export declare const listTransforming: (res: Process.RawPayload[], options: Proc
     status: "Enabled" | "Disabled" | "Enabled (dry-run)" | "Disabled (dry-run)";
 }[];
 export declare const handleVerbose: (res: Process.Payload, verbose: boolean) => Process.Payload;
-export declare const createProcess: (processRaw: Process.CliProcessInput, dryRun?: boolean, options?: Polkadot.Options, verbose?: boolean) => Promise<{
+export declare const createProcess: (processRaw: Process.CliProcessInput, dryRun: boolean | undefined, polkadot: Polkadot.Polkadot, options?: Polkadot.Options, verbose?: boolean) => Promise<{
     waitForFinalised: Promise<Process.ProcessResponse>;
 }>;
 export declare const disableProcess: (name: string, processVersion: number, dryRun?: boolean, options?: Polkadot.Options) => Promise<Process.ProcessResponse>;

package/build/src/lib/process/index.js

@@ -7,6 +7,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -67,32 +119,45 @@ export const sanitizeInput = (data) => {
     }
 };
 export const loadProcesses = (_a) => __awaiter(void 0, [_a], void 0, function* ({ data, options, dryRun, verbose, }) {
-    const parsedRes = sanitizeInput(data);
-    if (parsedRes.type === 'error') {
-        return parsedRes;
-    }
-    const processes = parsedRes.result;
-    const processTxs = new Map();
-    for (const process of processes) {
-        const { waitForFinalised } = yield createProcess(process, dryRun, options, verbose);
-        processTxs.set(process.name, waitForFinalised);
-    }
-    yield Promise.all(processTxs.values());
-    const result = {};
-    let successCount = 0;
-    for (const [key, processTxProm] of processTxs) {
-        let response = yield processTxProm;
-        result[key] = response;
-        if (response.type === 'ok') {
-            successCount = successCount + 1;
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const parsedRes = sanitizeInput(data);
+        if (parsedRes.type === 'error') {
+            return parsedRes;
+        }
+        const processes = parsedRes.result;
+        const processTxs = new Map();
+        const polkadot = __addDisposableResource(env_1, yield createNodeApi(options), true);
+        for (const process of processes) {
+            const { waitForFinalised } = yield createProcess(process, dryRun, polkadot, options, verbose);
+            processTxs.set(process.name, waitForFinalised);
         }
+        yield Promise.all(processTxs.values());
+        const result = {};
+        let successCount = 0;
+        for (const [key, processTxProm] of processTxs) {
+            let response = yield processTxProm;
+            result[key] = response;
+            if (response.type === 'ok') {
+                successCount = successCount + 1;
+            }
+        }
+        // calculate the result and successCount
+        return {
+            type: 'ok',
+            result,
+            message: `Successfully loaded ${successCount}/${processes.length} processes`,
+        };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            yield result_1;
     }
-    // calculate the result and successCount
-    return {
-        type: 'ok',
-        result,
-        message: `Successfully loaded ${successCount}/${processes.length} processes`,
-    };
 });
 export const listTransforming = (res, options) => {
     let processes;
@@ -124,7 +189,7 @@ export const handleVerbose = (res, verbose) => {
     const { program } = res, rest = __rest(res, ["program"]);
     return rest;
 };
-export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [processRaw_1, ...args_1], void 0, function* (processRaw, dryRun = false, options = defaultOptions, verbose = false) {
+export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [processRaw_1, ...args_1], void 0, function* (processRaw, dryRun = false, polkadot, options = defaultOptions, verbose = false) {
     const handleErr = (err) => {
         // err is basically from errors.ts or any exception
         // process errors will contain specific messages and/or process
@@ -154,7 +219,6 @@ export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [pro
     try {
         const { name, version, program } = processValidation.parse(processRaw);
         const processId = utf8ToHex(name);
-        const polkadot = yield createNodeApi(options);
         const currentVersion = yield getVersion(polkadot, processId);
         const expectedVersion = currentVersion + 1;
         if (version > expectedVersion || version < currentVersion)
@@ -210,26 +274,38 @@ export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [pro
     }
 });
 export const disableProcess = (name_1, processVersion_1, ...args_1) => __awaiter(void 0, [name_1, processVersion_1, ...args_1], void 0, function* (name, processVersion, dryRun = false, options = defaultOptions) {
-    const processId = utf8ToHex(name);
-    const polkadot = yield createNodeApi(options);
-    const currentProcess = yield getProcess(polkadot, processId, processVersion);
-    if (currentProcess.status === 'Disabled') {
-        throw new DisableError(`${name} with version ${processVersion} doesn't exist or is already disabled`);
-    }
-    if (dryRun) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const processId = utf8ToHex(name);
+        const polkadot = __addDisposableResource(env_2, yield createNodeApi(options), true);
+        const currentProcess = yield getProcess(polkadot, processId, processVersion);
+        if (currentProcess.status === 'Disabled') {
+            throw new DisableError(`${name} with version ${processVersion} doesn't exist or is already disabled`);
+        }
+        if (dryRun) {
+            return {
+                type: 'ok',
+                message: `This will DISABLE the following process ${name}`,
+                result: {
+                    name,
+                    version: processVersion,
+                    status: 'Disabled (dry-run)',
+                },
+            };
+        }
         return {
             type: 'ok',
-            message: `This will DISABLE the following process ${name}`,
-            result: {
-                name,
-                version: processVersion,
-                status: 'Disabled (dry-run)',
-            },
+            message: 'Process has been disabled',
+            result: yield disableProcessTransaction(polkadot, processId, processVersion, options),
         };
     }
-    return {
-        type: 'ok',
-        message: 'Process has been disabled',
-        result: yield disableProcessTransaction(polkadot, processId, processVersion, options),
-    };
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            yield result_2;
+    }
 });

package/build/src/lib/types/validation.d.ts

@@ -2479,6 +2479,7 @@ export declare const processValidation: z.ZodObject<{
         };
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
+    name: string;
     version: number;
     program: ({
         Op: "Identity" | "TransferL" | "TransferR" | "NotL" | "NotR" | "And" | "Nand" | "Or" | "Nor" | "Xor" | "Xnor" | "ImplicationL" | "ImplicationR" | "InhibitionL" | "InhibitionR";
@@ -2583,8 +2584,8 @@ export declare const processValidation: z.ZodObject<{
             };
         };
     })[];
-    name: string;
 }, {
+    name: string;
     version: number;
     program: ({
         Op: "Identity" | "TransferL" | "TransferR" | "NotL" | "NotR" | "And" | "Nand" | "Or" | "Nor" | "Xor" | "Xnor" | "ImplicationL" | "ImplicationR" | "InhibitionL" | "InhibitionR";
@@ -2689,7 +2690,6 @@ export declare const processValidation: z.ZodObject<{
             };
         };
     })[];
-    name: string;
 }>;
 export declare const simpleProcesssValidation: z.ZodArray<z.ZodObject<{
     name: z.ZodString;
@@ -3373,6 +3373,7 @@ export declare const processesValidation: z.ZodArray<z.ZodObject<{
         };
     }>]>, "many">;
 }, "strip", z.ZodTypeAny, {
+    name: string;
     version: number;
     program: ({
         Op: "Identity" | "TransferL" | "TransferR" | "NotL" | "NotR" | "And" | "Nand" | "Or" | "Nor" | "Xor" | "Xnor" | "ImplicationL" | "ImplicationR" | "InhibitionL" | "InhibitionR";
@@ -3477,8 +3478,8 @@ export declare const processesValidation: z.ZodArray<z.ZodObject<{
             };
         };
     })[];
-    name: string;
 }, {
+    name: string;
     version: number;
     program: ({
         Op: "Identity" | "TransferL" | "TransferR" | "NotL" | "NotR" | "And" | "Nand" | "Or" | "Nor" | "Xor" | "Xnor" | "ImplicationL" | "ImplicationR" | "InhibitionL" | "InhibitionR";
@@ -3583,7 +3584,6 @@ export declare const processesValidation: z.ZodArray<z.ZodObject<{
             };
         };
     })[];
-    name: string;
 }>, "many">;
 export type ValidationRestriction = z.infer<typeof restrictionValidation>;
 export type ValidationProgramStep = z.infer<typeof stepValidation>;

package/build/src/lib/utils/polkadot.d.ts

@@ -1 +1,6 @@
-export declare const createNodeApi: (options: Polkadot.Options) => Promise<Polkadot.Polkadot>;
+import { ApiPromise, Keyring } from '@polkadot/api';
+export declare const createNodeApi: (options: Polkadot.Options) => Promise<{
+    api: ApiPromise;
+    keyring: Keyring;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}>;

package/build/src/lib/utils/polkadot.js

@@ -21,5 +21,8 @@ export const createNodeApi = (options) => __awaiter(void 0, void 0, void 0, func
     return {
         api,
         keyring: new Keyring({ type: 'sr25519' }),
+        [Symbol.asyncDispose]: () => __awaiter(void 0, void 0, void 0, function* () {
+            yield api.disconnect();
+        }),
     };
 });

package/build/tests/helpers/containers.d.ts

@@ -0,0 +1,7 @@
+import { type StartedTestContainer } from 'testcontainers';
+export declare const withSubstrateNode: (config: {
+    manualSeal: boolean;
+}, context: {
+    nodeContainer?: StartedTestContainer;
+    polkadotOptions: Polkadot.Options;
+}) => void;

package/build/tests/helpers/containers.js

@@ -0,0 +1,40 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { GenericContainer, Wait } from 'testcontainers';
+import { resetLastSubmittedNonce } from '../../src/lib/process/api.js';
+export const withSubstrateNode = (config, context) => {
+    before(function () {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.timeout(60000);
+            resetLastSubmittedNonce();
+            context.nodeContainer = yield new GenericContainer('digicatapult/sqnc-node')
+                .withName('sqnc-node')
+                .withExposedPorts(30333, 9944, 9933)
+                .withCommand([
+                '--base-path',
+                '/data/',
+                '--dev',
+                '--unsafe-rpc-external',
+                '--rpc-cors',
+                'all',
+                ...(config.manualSeal ? ['--manual-seal'] : []),
+            ])
+                .withWaitStrategy(Wait.forHealthCheck())
+                .withReuse()
+                .start();
+            context.polkadotOptions.API_PORT = context.nodeContainer.getMappedPort(9944);
+        });
+    });
+    after(() => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        yield ((_a = context.nodeContainer) === null || _a === void 0 ? void 0 : _a.stop({ remove: true }));
+        resetLastSubmittedNonce();
+    }));
+};

package/build/tests/helpers/substrateHelper.d.ts

@@ -1,2 +1,2 @@
-export declare const getVersionHelper: (name: string) => Promise<number>;
-export declare const Helper: (processId: Process.Hex, version: number) => Promise<Process.Payload>;
+export declare const getVersionHelper: (name: string, options: Polkadot.Options) => Promise<number>;
+export declare const Helper: (processId: Process.Hex, version: number, options: Polkadot.Options) => Promise<Process.Payload>;

package/build/tests/helpers/substrateHelper.js

@@ -7,19 +7,94 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { createNodeApi } from '../../src/lib/utils/polkadot.js';
 import { getVersion, getProcess } from '../../src/lib/process/api.js';
-import { defaultOptions } from '../../src/lib/process/index.js';
 import { utf8ToHex } from '../../src/lib/process/hex.js';
-export const getVersionHelper = (name) => __awaiter(void 0, void 0, void 0, function* () {
-    const polkadot = yield createNodeApi(defaultOptions);
-    const version = yield getVersion(polkadot, utf8ToHex(name));
-    yield polkadot.api.disconnect();
-    return version;
+export const getVersionHelper = (name, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const polkadot = __addDisposableResource(env_1, yield createNodeApi(options), true);
+        const version = yield getVersion(polkadot, utf8ToHex(name));
+        yield polkadot.api.disconnect();
+        return version;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            yield result_1;
+    }
 });
-export const Helper = (processId, version) => __awaiter(void 0, void 0, void 0, function* () {
-    const polkadot = yield createNodeApi(defaultOptions);
-    const process = yield getProcess(polkadot, processId, version);
-    yield polkadot.api.disconnect();
-    return process;
+export const Helper = (processId, version, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const polkadot = __addDisposableResource(env_2, yield createNodeApi(options), true);
+        const process = yield getProcess(polkadot, processId, version);
+        yield polkadot.api.disconnect();
+        return process;
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            yield result_2;
+    }
 });

package/build/tests/integration/command-functions.test.js

@@ -7,6 +7,58 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 import { expect } from 'chai';
 import { createProcess, disableProcess, loadProcesses } from '../../src/lib/process/index.js';
 import { validAllRestrictions, invalidPOSIX, multiple, simple2, simple, invalidRestrictionKey, invalidRestrictionValue, } from '../fixtures/programs.js';
@@ -17,13 +69,31 @@ import { DisableError, ProgramError, VersionError } from '../../src/lib/types/er
 import { getAll } from '../../src/lib/process/api.js';
 /* fixtures */
 import processesExample from '../fixtures/processes.js';
-const polkadotOptions = { API_HOST: 'localhost', API_PORT: 9944, USER_URI: '//Alice', MANUAL_SEAL: true };
-const createProcessAndWait = (processRaw, dryRun, options, verbose) => __awaiter(void 0, void 0, void 0, function* () {
-    const { waitForFinalised } = yield createProcess(processRaw, dryRun, options, verbose);
-    const result = yield waitForFinalised;
-    return result;
+import { withSubstrateNode } from '../helpers/containers.js';
+import { createNodeApi } from '../../src/lib/utils/polkadot.js';
+const createProcessAndWait = (processRaw, options, dryRun, verbose) => __awaiter(void 0, void 0, void 0, function* () {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const polkadot = __addDisposableResource(env_1, yield createNodeApi(options), true);
+        const { waitForFinalised } = yield createProcess(processRaw, dryRun, polkadot, options, verbose);
+        const result = yield waitForFinalised;
+        return result;
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            yield result_1;
+    }
 });
 describe('Process creation and deletion, listing', () => {
+    const context = {
+        polkadotOptions: { API_HOST: 'localhost', API_PORT: 0, USER_URI: '//Alice', MANUAL_SEAL: true },
+    };
+    withSubstrateNode({ manualSeal: true }, context);
     describe('Happy path', () => {
         describe('Multiple processes', () => {
             it('skips already created processes and creates new ones', () => __awaiter(void 0, void 0, void 0, function* () {
@@ -31,11 +101,11 @@ describe('Process creation and deletion, listing', () => {
                     name: 'existing-process-test',
                     version: 1,
                     program: simple2,
-                }, false, polkadotOptions);
+                }, context.polkadotOptions, false);
                 const process2Name = 'process-to-be-created';
-                const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
                 const newProcesses = yield loadProcesses({
-                    options: polkadotOptions,
+                    options: context.polkadotOptions,
                     data: multiple('existing-process-test', 1, process2Name, process2BumpedV),
                 });
                 if (newProcesses.type !== 'ok') {
@@ -62,11 +132,11 @@ describe('Process creation and deletion, listing', () => {
             }));
             it('creates multiple processes', () => __awaiter(void 0, void 0, void 0, function* () {
                 const process1Name = 'process-1';
-                const process1BumpedV = (yield getVersionHelper(process1Name)) + 1;
+                const process1BumpedV = (yield getVersionHelper(process1Name, context.polkadotOptions)) + 1;
                 const process2Name = 'process-2';
-                const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
                 const newProcesses = yield loadProcesses({
-                    options: polkadotOptions,
+                    options: context.polkadotOptions,
                     data: multiple(process1Name, process1BumpedV, process2Name, process2BumpedV),
                 });
                 if (newProcesses.type !== 'ok') {
@@ -92,8 +162,8 @@ describe('Process creation and deletion, listing', () => {
                 });
             }));
             it('loads and skips multiple processes using number values', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield loadProcesses({ options: polkadotOptions, data: JSON.stringify(processesExample) });
-                const res = yield loadProcesses({ options: polkadotOptions, data: JSON.stringify(processesExample) });
+                yield loadProcesses({ options: context.polkadotOptions, data: JSON.stringify(processesExample) });
+                const res = yield loadProcesses({ options: context.polkadotOptions, data: JSON.stringify(processesExample) });
                 if (res.type !== 'ok') {
                     expect.fail('Expected process create to succeed');
                 }
@@ -116,9 +186,9 @@ describe('Process creation and deletion, listing', () => {
         });
         it('creates then disables a process', () => __awaiter(void 0, void 0, void 0, function* () {
             const processName = '0';
-            const currentVersion = yield getVersionHelper(processName);
+            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: simple }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: simple }, context.polkadotOptions, false);
             if (newProcess.type !== 'ok') {
                 expect.fail('Expected process creation to succeed');
             }
@@ -127,7 +197,7 @@ describe('Process creation and deletion, listing', () => {
                 version: bumpedVersion,
                 status: 'Enabled',
             });
-            const disabledProcess = yield disableProcess(processName, bumpedVersion, false, polkadotOptions);
+            const disabledProcess = yield disableProcess(processName, bumpedVersion, false, context.polkadotOptions);
             if (disabledProcess.type !== 'ok') {
                 expect.fail('Expected process disable to succeed');
             }
@@ -140,9 +210,9 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('does not create process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
             const processName = '0';
-            const currentVersion = yield getVersionHelper(processName);
+            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, true, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, context.polkadotOptions, true);
             if (newProcess.type !== 'ok') {
                 expect.fail('Expected process create to succeed');
             }
@@ -155,11 +225,11 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('does not disable process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
             const processName = '0';
-            const currentVersion = yield getVersionHelper(processName);
+            const currentVersion = yield getVersionHelper(processName, context.polkadotOptions);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, context.polkadotOptions, false);
             expect(newProcess.type).to.equal('ok');
-            const disabledProcess = yield disableProcess(processName, bumpedVersion, true, polkadotOptions);
+            const disabledProcess = yield disableProcess(processName, bumpedVersion, true, context.polkadotOptions);
             if (disabledProcess.type !== 'ok') {
                 expect.fail('Expected disable process to succeed');
             }
@@ -173,7 +243,7 @@ describe('Process creation and deletion, listing', () => {
         }));
         // it('returns a list of raw processes when with --verbose flag', () => {
         it('returns a list of processes', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield getAll(polkadotOptions);
+            const res = yield getAll(context.polkadotOptions);
             expect(res).to.be.an('array');
             expect(res[0])
                 .to.be.an('object')
@@ -184,18 +254,18 @@ describe('Process creation and deletion, listing', () => {
         const validProcessName = '0';
         let validVersionNumber;
         before(() => __awaiter(void 0, void 0, void 0, function* () {
-            const currentVersion = yield getVersionHelper(validProcessName);
+            const currentVersion = yield getVersionHelper(validProcessName, context.polkadotOptions);
             validVersionNumber = currentVersion + 1;
         }));
         describe('If process already exists', () => {
             describe('Multiple uploads', () => {
                 // TODO could prestage in before if more scenarios
                 it('skips and notifies if process programs are different', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcessAndWait({ name: 'existing-length', version: 1, program: validAllRestrictions }, false, polkadotOptions);
+                    yield createProcessAndWait({ name: 'existing-length', version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
                     const process2Name = 'should-create-1';
-                    const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                    const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
                     const res = yield loadProcesses({
-                        options: polkadotOptions,
+                        options: context.polkadotOptions,
                         data: multiple('existing-length', 1, process2Name, process2BumpedV),
                     });
                     if (res.type !== 'ok') {
@@ -213,11 +283,11 @@ describe('Process creation and deletion, listing', () => {
                     expect(process2Res.message).to.equal('Transaction for new process should-create-1 has been successfully submitted');
                 }));
                 it('also fails if number of steps matches but POSTFIX does not', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcessAndWait({ name: 'existing-steps', version: 1, program: simple }, false, polkadotOptions);
+                    yield createProcessAndWait({ name: 'existing-steps', version: 1, program: simple }, context.polkadotOptions, false);
                     const process2Name = 'should-create-2';
-                    const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                    const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
                     const res = yield loadProcesses({
-                        options: polkadotOptions,
+                        options: context.polkadotOptions,
                         data: multiple('existing-steps', 1, process2Name, process2BumpedV),
                     });
                     // TODO: should this fail
@@ -229,8 +299,8 @@ describe('Process creation and deletion, listing', () => {
                 }));
             });
             it('does not create new one and notifies if programs are different length', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcessAndWait({ name: 'existing-single', version: 1, program: validAllRestrictions }, false, polkadotOptions);
-                const res = yield createProcessAndWait({ name: 'existing-single', version: 1, program: simple }, false, polkadotOptions);
+                yield createProcessAndWait({ name: 'existing-single', version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
+                const res = yield createProcessAndWait({ name: 'existing-single', version: 1, program: simple }, context.polkadotOptions, false);
                 if (res.type !== 'error') {
                     expect.fail('Expected program create with different lengths to fail');
                 }
@@ -238,8 +308,8 @@ describe('Process creation and deletion, listing', () => {
                 expect(res.error).to.instanceOf(ProgramError);
             }));
             it('does not create new one and notifies if programs same are length but do not match', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: simple2 }, false, polkadotOptions);
-                const res = yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: [{ Restriction: 'None' }] }, false, polkadotOptions);
+                yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: simple2 }, context.polkadotOptions, false);
+                const res = yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: [{ Restriction: 'None' }] }, context.polkadotOptions, false);
                 if (res.type !== 'error') {
                     expect.fail('Expected program create with different lengths to fail');
                 }
@@ -254,7 +324,7 @@ describe('Process creation and deletion, listing', () => {
             }));
         });
         it('fails for invalid POSTFIX notation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidPOSIX }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidPOSIX }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -266,7 +336,7 @@ describe('Process creation and deletion, listing', () => {
                 name: validProcessName,
                 version: validVersionNumber,
                 program: invalidRestrictionKey,
-            }, false, polkadotOptions);
+            }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -278,14 +348,14 @@ describe('Process creation and deletion, listing', () => {
             });
         }));
         it('fails for invalid restriction value', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidRestrictionValue }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidRestrictionValue }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
             expect(res.error).to.be.instanceOf(ZodError);
         }));
         it('fails for invalid json', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: 'invalidJson' }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: 'invalidJson' }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -293,7 +363,7 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('fails to create for too low version', () => __awaiter(void 0, void 0, void 0, function* () {
             // - 2 because -1 would make current = valid
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber - 2, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber - 2, program: validAllRestrictions }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -301,7 +371,7 @@ describe('Process creation and deletion, listing', () => {
             expect(res.error).to.be.instanceOf(VersionError);
         }));
         it('fails to create for too high version', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber + 1, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber + 1, program: validAllRestrictions }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -310,7 +380,7 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('fails to create with too long process id', () => __awaiter(void 0, void 0, void 0, function* () {
             const processName = '0'.repeat(Constants.PROCESS_ID_LENGTH + 1);
-            const res = yield createProcessAndWait({ name: processName, version: 1, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: processName, version: 1, program: validAllRestrictions }, context.polkadotOptions, false);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -319,7 +389,7 @@ describe('Process creation and deletion, listing', () => {
         it('fails to disable process that does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
             let err = null;
             try {
-                yield disableProcess('incorrectProcessName', 1, false, polkadotOptions);
+                yield disableProcess('incorrectProcessName', 1, false, context.polkadotOptions);
             }
             catch (error) {
                 err = error;
@@ -327,13 +397,13 @@ describe('Process creation and deletion, listing', () => {
             expect(err).instanceOf(DisableError);
         }));
         it('fails to disable process a second time', () => __awaiter(void 0, void 0, void 0, function* () {
-            const newProcess = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: simple }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: simple }, context.polkadotOptions, false);
             expect(newProcess.type).to.equal('ok');
-            const firstDisable = yield disableProcess(validProcessName, validVersionNumber, false, polkadotOptions);
+            const firstDisable = yield disableProcess(validProcessName, validVersionNumber, false, context.polkadotOptions);
             expect(firstDisable.type).to.equal('ok');
             let err = null;
             try {
-                yield disableProcess(validProcessName, validVersionNumber, false, polkadotOptions);
+                yield disableProcess(validProcessName, validVersionNumber, false, context.polkadotOptions);
             }
             catch (error) {
                 err = error;

package/build/tests/integration/without-manual-seal.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/tests/integration/without-manual-seal.test.js

@@ -0,0 +1,52 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { expect } from 'chai';
+import { loadProcesses } from '../../src/lib/process/index.js';
+import { multiple } from '../fixtures/programs.js';
+import { getVersionHelper } from '../helpers/substrateHelper.js';
+import { withSubstrateNode } from '../helpers/containers.js';
+describe('Transactions without manual seal', function () {
+    this.timeout(60000);
+    const context = {
+        polkadotOptions: { API_HOST: 'localhost', API_PORT: 0, USER_URI: '//Alice', MANUAL_SEAL: false },
+    };
+    withSubstrateNode({ manualSeal: false }, context);
+    it('creates multiple processes', () => __awaiter(this, void 0, void 0, function* () {
+        const process1Name = 'process-1';
+        const process1BumpedV = (yield getVersionHelper(process1Name, context.polkadotOptions)) + 1;
+        const process2Name = 'process-2';
+        const process2BumpedV = (yield getVersionHelper(process2Name, context.polkadotOptions)) + 1;
+        const newProcesses = yield loadProcesses({
+            options: context.polkadotOptions,
+            data: multiple(process1Name, process1BumpedV, process2Name, process2BumpedV),
+        });
+        if (newProcesses.type !== 'ok') {
+            expect.fail('Expected new process creation to succeed');
+        }
+        expect(newProcesses.result[process1Name].message).to.deep.equal('Transaction for new process process-1 has been successfully submitted');
+        const process1Result = newProcesses.result[process1Name];
+        if (process1Result.type !== 'ok') {
+            expect.fail('Expected process1 creation to succeed');
+        }
+        expect(process1Result.result).to.deep.contain({
+            version: process1BumpedV,
+            status: 'Enabled',
+        });
+        const process2Result = newProcesses.result[process2Name];
+        if (process2Result.type !== 'ok') {
+            expect.fail('Expected process2 creation to succeed');
+        }
+        expect(process2Result.message).to.deep.equal('Transaction for new process process-2 has been successfully submitted');
+        expect(process2Result.result).to.deep.contain({
+            version: process2BumpedV,
+            status: 'Enabled',
+        });
+    }));
+});

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/version.ts","../src/lib/process/api.ts","../src/lib/process/constants.ts","../src/lib/process/hex.ts","../src/lib/process/index.ts","../src/lib/process/_tests_/unit.test.ts","../src/lib/types/error.ts","../src/lib/types/polkadot.d.ts","../src/lib/types/process.d.ts","../src/lib/types/validation.ts","../src/lib/utils/polkadot.ts","../tests/fixtures/processes.ts","../tests/fixtures/programs.ts","../tests/helpers/substrateHelper.ts","../tests/integration/command-functions.test.ts"],"version":"5.6.3"}
+{"root":["../src/index.ts","../src/version.ts","../src/lib/process/api.ts","../src/lib/process/constants.ts","../src/lib/process/hex.ts","../src/lib/process/index.ts","../src/lib/process/_tests_/unit.test.ts","../src/lib/types/error.ts","../src/lib/types/polkadot.d.ts","../src/lib/types/process.d.ts","../src/lib/types/validation.ts","../src/lib/utils/polkadot.ts","../tests/fixtures/processes.ts","../tests/fixtures/programs.ts","../tests/helpers/containers.ts","../tests/helpers/substrateHelper.ts","../tests/integration/command-functions.test.ts","../tests/integration/without-manual-seal.test.ts"],"version":"5.6.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digicatapult/sqnc-process-management",
-  "version": "2.2.128",
+  "version": "2.2.129",
   "description": "SQNC Process Management Flow",
   "main": "./lib/index.js",
   "bin": {
@@ -51,6 +51,7 @@
     "mocha": "^10.8.2",
     "nodemon": "^3.1.7",
     "prettier": "^3.3.3",
+    "testcontainers": "^10.14.0",
     "ts-mocha": "^10.0.0",
     "ts-node": "^10.9.2"
   },