@digicatapult/sqnc-process-management 2.2.131 → 2.2.132

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digicatapult/sqnc-process-management",
-  "version": "2.2.131",
+  "version": "2.2.132",
   "description": "SQNC Process Management Flow",
   "main": "./lib/index.js",
   "bin": {
@@ -8,14 +8,14 @@
   },
   "type": "module",
   "scripts": {
-    "start": "node --loader ts-node/esm src/index.ts",
+    "start": "SWCRC=true NODE_ENV=production node --import @swc-node/register/esm-register --enable-source-maps src/index.ts",
     "local": "npm i -g && process-management",
-    "dev": "nodemon --watch 'src/**/*.ts' --exec node --loader ts-node/esm src/index.ts",
+    "dev": "NODE_ENV=dev nodemon --watch 'src/**/*.ts' --exec node --import @swc-node/register/esm-register --enable-source-maps src/index.ts",
     "lint": "eslint .",
-    "build": "tsc --build",
+    "build": "swc ./src -d ./build --strip-leading-paths --copy-files",
     "depcheck": "depcheck",
-    "test": "ts-mocha --config ./tests/mocharc.json -n  loader=ts-node/esm -p tsconfig.json tests/**/*.test.ts --exit",
-    "test:unit": "ts-mocha --config ./tests/mocharc.json -n loader=ts-node/esm -p tsconfig.json src/**/*.test.ts --exit",
+    "test": "SWCRC=true NODE_ENV=test node --enable-source-maps ./node_modules/.bin/mocha --config ./test/mocharc.json test/**/*.test.ts",
+    "test:unit": "SWCRC=true NODE_ENV=test node --enable-source-maps ./node_modules/.bin/mocha --config ./test/mocharc.json src/**/*.test.ts --exit",
     "prettier": "npx prettier --write ."
   },
   "repository": {
@@ -38,6 +38,10 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.15.0",
+    "@swc-node/register": "^1.10.9",
+    "@swc/cli": "^0.5.1",
+    "@swc/core": "^1.9.2",
+    "@swc/helpers": "^0.5.15",
     "@types/chai": "^5.0.1",
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.64",
@@ -51,15 +55,13 @@
     "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"
+    "reflect-metadata": "^0.2.2",
+    "testcontainers": "^10.14.0"
   },
   "dependencies": {
     "@polkadot/api": "^14.3.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
-    "typescript": "^5.6.3",
     "zod": "^3.23.8"
   }
 }

package/build/package.json

@@ -1,65 +0,0 @@
-{
-    "name": "@digicatapult/sqnc-process-management",
-    "version": "2.2.131",
-    "description": "SQNC Process Management Flow",
-    "main": "./lib/index.js",
-    "bin": {
-        "process-management": "./build/src/index.js"
-    },
-    "type": "module",
-    "scripts": {
-        "start": "node --loader ts-node/esm src/index.ts",
-        "local": "npm i -g && process-management",
-        "dev": "nodemon --watch 'src/**/*.ts' --exec node --loader ts-node/esm src/index.ts",
-        "lint": "eslint .",
-        "build": "tsc --build",
-        "depcheck": "depcheck",
-        "test": "ts-mocha --config ./tests/mocharc.json -n  loader=ts-node/esm -p tsconfig.json tests/**/*.test.ts --exit",
-        "test:unit": "ts-mocha --config ./tests/mocharc.json -n loader=ts-node/esm -p tsconfig.json src/**/*.test.ts --exit",
-        "prettier": "npx prettier --write ."
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/digicatapult/sqnc-process-management.git"
-    },
-    "files": [
-        "/build"
-    ],
-    "engines": {
-        "node": ">=20.x.x",
-        "npm": ">=10.x.x"
-    },
-    "author": "Digital Catapult",
-    "license": "Apache-2.0",
-    "bugs": {
-        "url": "https://github.com/digicatapult/sqnc-process-management/issues"
-    },
-    "homepage": "https://github.com/digicatapult/sqnc-process-management#readme",
-    "devDependencies": {
-        "@eslint/eslintrc": "^3.2.0",
-        "@eslint/js": "^9.15.0",
-        "@types/chai": "^5.0.1",
-        "@types/mocha": "^10.0.10",
-        "@types/node": "^18.19.64",
-        "@typescript-eslint/eslint-plugin": "^8.15.0",
-        "@typescript-eslint/parser": "^8.15.0",
-        "chai": "^5.1.2",
-        "depcheck": "^1.4.7",
-        "eslint": "^9.15.0",
-        "eslint-config-prettier": "^9.1.0",
-        "eslint-plugin-prettier": "^5.2.1",
-        "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"
-    },
-    "dependencies": {
-        "@polkadot/api": "^14.3.1",
-        "chalk": "^5.3.0",
-        "commander": "^12.1.0",
-        "typescript": "^5.6.3",
-        "zod": "^3.23.8"
-    }
-}

package/build/src/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-export {};

package/build/src/index.js

@@ -1,127 +0,0 @@
-#!/usr/bin/env -S node --no-warnings
-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 fs from 'fs/promises';
-import chalk from 'chalk';
-import { Command } from 'commander';
-import { loadProcesses, disableProcess, listTransforming } from './lib/process/index.js';
-import { getAll } from './lib/process/api.js';
-import cliVersion from './version.js';
-const unwrap = (res) => {
-    if (res.type === 'ok')
-        return res.result;
-    else
-        throw res.error;
-};
-const { log, dir } = console;
-const program = new Command();
-const { red: r, blue: b } = {
-    red: (txt) => chalk.redBright(txt),
-    blue: (txt) => chalk.blueBright(txt),
-};
-const mapOptions = (options) => ({
-    API_HOST: options.host,
-    API_PORT: parseInt(options.port),
-    USER_URI: options.user,
-});
-// TODO nice to have, a local config file for substrate host details e.g. name, port, address
-// so no need to parse every time calling a command, or ability to set
-program
-    .name('process management')
-    .description('a command line interface for managing chain processes')
-    .version(cliVersion, '-v, --version', 'output current version')
-    .helpOption('--help', 'display help for command'); //override -h
-program
-    .command('list')
-    .description('A command for listing all active process flows')
-    .option('-v, --verbose', 'Returns all information about the transation, default - false')
-    .option('-h, --host <host>', 'substrate blockchain host address or FQDM, default - "localhost"', 'localhost')
-    .option('-p, --port <port>', 'specify host port number if it is not a default, default - 9944', '9944')
-    .option('--raw', 'print processes with hex values and extra keys such as "createdAtHash"')
-    .option('--active', 'returns only active process flows')
-    .option('--disabled', 'returns only disabled process flows')
-    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.print)
-        log(`
-      retrieving all process flows from a chain...
-      options: ${b(JSON.stringify(options))}
-    `);
-    try {
-        const res = yield getAll(mapOptions(options));
-        const transformed = listTransforming(res, options);
-        dir(transformed, { depth: null });
-        process.exit(0);
-    }
-    catch (err) {
-        log(err);
-        process.exit(1);
-    }
-}));
-program
-    .command('create')
-    .description('A command for persisting process flows onto the chain')
-    .option('--dryRun', 'to validate process and response locally before persisting on the chain, default - false')
-    .option('--verbose', 'Returns all information about the transation, default - false')
-    .option('-h, --host <host>', 'substrate blockchain host address or FQDM, default - "localhost"', 'localhost')
-    .option('-p, --port <port>', 'specify host port number if it is not a default, default - 9944', '9944')
-    .requiredOption('-f, --file <file>', 'path to file containing process flows to loads')
-    .requiredOption('-u, --user <user>', 'specify substrate blockchain user URI')
-    .action((options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.print)
-        log(`
-      attempting to create a process...
-      options: ${b(JSON.stringify(options))}
-    `);
-    const { dryRun, verbose } = options;
-    try {
-        const data = (yield fs.readFile(options.file)).toString('utf8');
-        const loadResult = yield loadProcesses({ data, dryRun, options: mapOptions(options), verbose });
-        dir(loadResult.message, { depth: null });
-        dir(unwrap(loadResult), { depth: null });
-        process.exit(0);
-    }
-    catch (err) {
-        log(err);
-        process.exit(1);
-    }
-}));
-program
-    .command('disable')
-    .description('A command for disabling an existing process flows. Required process ID and version')
-    .option('--dryRun', 'to validate process and response locally before persisting on the chain, default - false')
-    .option('-h, --host <host>', 'substrate blockchain host address or FQDM, default - "localhost"', 'localhost')
-    .option('-p, --port <port>', 'specify host port number if it is not a default, default - 9944', '9944')
-    .requiredOption('-u, --user <user>', 'specify substrate blockchain user URI')
-    .argument('<id>', 'a valid process id that you would like to disable')
-    .argument('<version>', 'a version number of a process')
-    .action((id, version, options) => __awaiter(void 0, void 0, void 0, function* () {
-    if (options.print)
-        log(`attempting to disable:\nID:${b(id)}\nVersion:${b(version)}`);
-    try {
-        const { dryRun } = options;
-        const res = unwrap(yield disableProcess(id, parseInt(version), dryRun, mapOptions(options)));
-        dir(res, { depth: null });
-        process.exit(0);
-    }
-    catch (err) {
-        log(err);
-        process.exit(1);
-    }
-}));
-program.parse();
-if (!program.option) {
-    program.help();
-}
-program.on('command:*', function () {
-    log(`
-    ${r('Invalid command: %s\nSee --help for a list of available commands.')}
-    ${program.args.join(' ')}`);
-    process.exit(127);
-});

package/build/src/lib/process/_tests_/unit.test.d.ts

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

package/build/src/lib/process/_tests_/unit.test.js

@@ -1,112 +0,0 @@
-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 { utf8ToHex, hexToUtf8 } from '../hex.js';
-import { listTransforming, handleVerbose } from '../index.js';
-import sample from '../../../../tests/fixtures/processes.js';
-const defaultPolkadot = {
-    port: '9044',
-    user: 'alice',
-    host: 'localhost',
-    file: './exampleProcess.json',
-};
-describe('utf8ToHex', () => {
-    it('converts a utf8 string to hexadecimal', () => {
-        expect(utf8ToHex('test123')).to.equal('0x74657374313233');
-    });
-});
-describe('hexToUtf8', () => {
-    it('converts a prefixed string to hex', () => {
-        expect(hexToUtf8('0x74657374313233')).to.equal('test123');
-    });
-});
-describe('listTranforming', () => {
-    it('returns all transformed processes without a program (--verbose=false)', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Enabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { verbose: false }));
-        expect(res[0]).to.deep.contain({
-            name: '123',
-            status: 'Enabled',
-            version: 1,
-        });
-    }));
-    it('returns all transformed processes with a program (--verbose=true)', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { verbose: true }));
-        expect(res[0]).to.deep.contain({
-            name: '123',
-            status: 'Disabled',
-            version: 1,
-        });
-    }));
-    it('returns all options active', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Enabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: true }));
-        expect(res[0]).to.deep.contain({
-            name: '123',
-            status: 'Enabled',
-            version: 1,
-        });
-    }));
-    it('returns all options disabled but with active true', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: true }));
-        expect(res[0]).to.equal(undefined);
-    }));
-    it('returns all options disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign({}, defaultPolkadot));
-        expect(res[0]).to.deep.contain({
-            name: '123',
-            status: 'Disabled',
-            version: 1,
-        });
-    }));
-    it('returns all options active with status enabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: false }));
-        expect(res[0]).to.deep.contain({
-            name: '123',
-            status: 'Disabled',
-            version: 1,
-        });
-    }));
-    it('returns additional properties with raw', () => __awaiter(void 0, void 0, void 0, function* () {
-        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
-        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: false, raw: true }));
-        expect(res[0]).to.deep.contain({
-            name: '0x313233',
-            status: 'Disabled',
-            version: 1,
-            createdAtHash: 'abc',
-            initialU8aLength: '32',
-        });
-    }));
-});
-describe('handleVerbose', function () {
-    it('should remove program when verbose == false', function () {
-        const result = handleVerbose({
-            name: 'test',
-            status: 'Enabled',
-            version: 1,
-            program: [],
-        }, false);
-        expect(result).to.deep.equal({ name: 'test', status: 'Enabled', version: 1 });
-    });
-    it('should include program when verbose == false', function () {
-        const result = handleVerbose({
-            name: 'test',
-            status: 'Enabled',
-            version: 1,
-            program: [],
-        }, true);
-        expect(result).to.deep.equal({ name: 'test', status: 'Enabled', version: 1, program: [] });
-    });
-});

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

@@ -1,10 +0,0 @@
-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>;
-}>;
-export declare const disableProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, version: number, options: Polkadot.Options) => Promise<Process.Payload>;
-type GetAllFn = (options: Polkadot.Options) => Promise<Process.RawPayload[]>;
-export declare const getAll: GetAllFn;
-export declare const getVersion: (polkadot: Polkadot.Polkadot, processId: Process.Hex) => Promise<number>;
-export declare const getProcess: (polkadot: Polkadot.Polkadot, processId: Process.Hex, version: number) => Promise<Process.Payload>;
-export {};

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

@@ -1,193 +0,0 @@
-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());
-    });
-};
-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';
-// TODO - refactor to validate payload?
-// for some reason reduce did not work with Process.Program or ProgramStep[] type due to symbol.iterator
-const isProgramValid = (program, out = { ops: 0, restrictions: -1 }) => {
-    program.forEach((step) => {
-        out = Object.hasOwn(step, 'Op') ? Object.assign(Object.assign({}, out), { ops: out.ops + 1 }) : Object.assign(Object.assign({}, out), { restrictions: out.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* () {
-    const sudo = polkadot.keyring.addFromUri(options.USER_URI);
-    const supportsManualSeal = !!polkadot.api.rpc.engine.createBlock;
-    if (!isProgramValid(program))
-        throw new ProgramError('invalid program');
-    let resolve = () => { };
-    let reject = () => { };
-    const result = new Promise((res, rej) => {
-        resolve = res;
-        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 }, (result) => {
-            if (result.status.isFinalized) {
-                const { event } = result.events.find(({ event: { method } }) => method === 'ProcessCreated');
-                const data = event.data;
-                const newProcess = {
-                    name: data[0].toHuman(),
-                    version: data[1].toNumber(),
-                    status: 'Enabled',
-                    program,
-                };
-                unsub();
-                resolve(newProcess);
-            }
-        });
-        if (supportsManualSeal) {
-            yield polkadot.api.rpc.engine.createBlock(true, true);
-        }
-    }
-    catch (err) {
-        reject(err);
-    }
-    return {
-        waitForFinal: result,
-    };
-});
-export const disableProcessTransaction = (polkadot, processId, version, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const sudo = polkadot.keyring.addFromUri(options.USER_URI);
-    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, { nonce }, (result) => {
-                if (result.status.isFinalized) {
-                    const { event } = result.events.find(({ event: { method } }) => method === 'ProcessDisabled');
-                    const data = event.data;
-                    const disabledProcess = {
-                        name: data[0].toHuman(),
-                        version: data[1].toNumber(),
-                        status: 'Disabled',
-                    };
-                    unsub();
-                    resolve(disabledProcess);
-                }
-            });
-            if (supportsManualSeal) {
-                yield polkadot.api.rpc.engine.createBlock(true, true);
-            }
-        }
-        catch (err) {
-            reject(err);
-        }
-    }));
-});
-export const getAll = (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 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);
-    return Number(id.toString());
-});
-export const getProcess = (polkadot, processId, version) => __awaiter(void 0, void 0, void 0, function* () {
-    const result = yield polkadot.api.query.processValidation.processModel(processId, version);
-    const data = Object(result.toHuman());
-    return {
-        name: hexToUtf8(processId),
-        version,
-        status: data.status,
-        program: data.program,
-    };
-});

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

@@ -1,3 +0,0 @@
-export declare abstract class Constants {
-    static readonly PROCESS_ID_LENGTH: number;
-}

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

@@ -1,3 +0,0 @@
-export class Constants {
-}
-Constants.PROCESS_ID_LENGTH = 32;

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

@@ -1,2 +0,0 @@
-export declare const utf8ToHex: (str: string) => Process.Hex;
-export declare const hexToUtf8: (str: Process.Hex) => string;

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

@@ -1,22 +0,0 @@
-import { CliInputParseError } from '../types/error.js';
-export declare const defaultOptions: Polkadot.Options;
-export declare const sanitizeInput: (data: string) => Process.Result<{
-    name: string;
-}[], CliInputParseError>;
-export declare const loadProcesses: ({ data, options, dryRun, verbose, }: {
-    data: string;
-    options: Polkadot.Options;
-    dryRun?: boolean;
-    verbose?: boolean;
-}) => Promise<Process.Response>;
-export declare const listTransforming: (res: Process.RawPayload[], options: Process.CLIOptions) => {
-    program?: any;
-    name: string;
-    version: number;
-    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 | 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>;