@digicatapult/sqnc-process-management 2.2.131 → 2.2.132

package/build/lib/process/index.js

@@ -0,0 +1,304 @@
+function _ts_add_disposable_resource(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;
+}
+function _ts_dispose_resources(env) {
+    var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+    return (_ts_dispose_resources = function _ts_dispose_resources(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();
+    })(env);
+}
+import { createNodeApi } from '../utils/polkadot.js';
+import { createProcessTransaction, disableProcessTransaction, getVersion, getProcess } from './api.js';
+import { utf8ToHex } from './hex.js';
+import { processValidation, simpleProcesssValidation } from '../types/validation.js';
+import { CliInputParseError, DisableError, ProgramError, VersionError } from '../types/error.js';
+import { ZodError } from 'zod';
+export const defaultOptions = {
+    API_HOST: 'localhost',
+    API_PORT: 9944,
+    USER_URI: '//Alice'
+};
+const textify = (obj)=>{
+    return JSON.stringify(obj, (_key, val)=>{
+        // convert snake case to camel case
+        if (val && typeof val === 'object') {
+            return Object.fromEntries(Object.entries(val).map(([k, v])=>{
+                return [
+                    [
+                        ...k
+                    ].map((c, i)=>k[i - 1] === '_' ? c.toUpperCase() : c).filter((c)=>c != '_').join(''),
+                    v
+                ];
+            }));
+        }
+        if (typeof val === 'number') return val.toString();
+        return val;
+    });
+};
+export const sanitizeInput = (data)=>{
+    try {
+        return {
+            type: 'ok',
+            result: simpleProcesssValidation.parse(JSON.parse(data))
+        };
+    } catch (err) {
+        if (err instanceof Error) {
+            return {
+                type: 'error',
+                error: new CliInputParseError(err),
+                message: err.message
+            };
+        }
+        throw err;
+    }
+};
+export const loadProcesses = async ({ data, options, dryRun, verbose })=>{
+    const env = {
+        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 = _ts_add_disposable_resource(env, await createNodeApi(options), true);
+        for (const process of processes){
+            const { waitForFinalised } = await createProcess(process, dryRun, polkadot, options, verbose);
+            processTxs.set(process.name, waitForFinalised);
+        }
+        await Promise.all(processTxs.values());
+        const result = {};
+        let successCount = 0;
+        for (const [key, processTxProm] of processTxs){
+            let response = await 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) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+};
+export const listTransforming = (res, options)=>{
+    let processes;
+    if (options.active) {
+        processes = res.filter(({ status })=>status === 'Enabled');
+    } else if (options.disabled) {
+        processes = res.filter(({ status })=>status === 'Disabled');
+    } else {
+        processes = res;
+    }
+    if (options.raw) {
+        return processes.map(({ name, program, ...p })=>({
+                name: utf8ToHex(name),
+                ...options.verbose ? {
+                    program
+                } : {},
+                ...p
+            }));
+    } else {
+        return processes.map((p)=>{
+            return {
+                name: p.name,
+                version: p.version,
+                status: p.status,
+                ...options.verbose ? {
+                    program: p.program
+                } : {}
+            };
+        });
+    }
+};
+export const handleVerbose = (res, verbose)=>{
+    if (verbose) {
+        return res;
+    }
+    const { program, ...rest } = res;
+    return rest;
+};
+export const createProcess = async (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
+        // Promise<Process.Result> is in try {} and any exception is in catch {}
+        if (err instanceof ProgramError || err instanceof VersionError || err instanceof ZodError) {
+            const result = {
+                type: 'error',
+                error: err,
+                message: err.message
+            };
+            return {
+                waitForFinalised: Promise.resolve(result)
+            };
+        } else if (err instanceof Error) {
+            const result = {
+                type: 'error',
+                error: err,
+                message: 'An unknown error occurred'
+            };
+            return {
+                waitForFinalised: Promise.resolve(result)
+            };
+        }
+        throw err;
+    };
+    try {
+        const { name, version, program } = processValidation.parse(processRaw);
+        const processId = utf8ToHex(name);
+        const currentVersion = await getVersion(polkadot, processId);
+        const expectedVersion = currentVersion + 1;
+        if (version > expectedVersion || version < currentVersion) throw new VersionError(version, expectedVersion, name);
+        if (version === currentVersion) {
+            const process = await getProcess(polkadot, processId, version);
+            if (program.length !== process.program.length) throw new ProgramError('existing: programs are different lengths', process);
+            if (!program.every((step, i)=>textify(step) === textify(process.program[i]))) throw new ProgramError('existing: program steps did not match', process);
+            return {
+                waitForFinalised: Promise.resolve({
+                    type: 'ok',
+                    message: `Skipping: process ${name} is already created.`,
+                    result: handleVerbose({
+                        name,
+                        version,
+                        program,
+                        status: process.status
+                    }, verbose)
+                })
+            };
+        }
+        if (dryRun) return {
+            waitForFinalised: Promise.resolve({
+                type: 'ok',
+                message: 'Dry run: transaction has not been created',
+                result: handleVerbose({
+                    name,
+                    version,
+                    program,
+                    status: 'Enabled (dry-run)'
+                }, verbose)
+            })
+        };
+        const createProcessTx = await createProcessTransaction(polkadot, processId, program, options);
+        return {
+            waitForFinalised: createProcessTx.waitForFinal.then((process)=>{
+                const result = {
+                    type: 'ok',
+                    message: `Transaction for new process ${name} has been successfully submitted`,
+                    result: handleVerbose(process, verbose)
+                };
+                return result;
+            }).catch((err)=>handleErr(err).waitForFinalised)
+        };
+    } catch (err) {
+        return handleErr(err);
+    }
+};
+export const disableProcess = async (name, processVersion, dryRun = false, options = defaultOptions)=>{
+    const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+    };
+    try {
+        const processId = utf8ToHex(name);
+        const polkadot = _ts_add_disposable_resource(env, await createNodeApi(options), true);
+        const currentProcess = await 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: 'Process has been disabled',
+            result: await disableProcessTransaction(polkadot, processId, processVersion, options)
+        };
+    } catch (e) {
+        env.error = e;
+        env.hasError = true;
+    } finally{
+        const result = _ts_dispose_resources(env);
+        if (result) await result;
+    }
+};
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/process/index.ts"],"sourcesContent":["import { createNodeApi } from '../utils/polkadot.js'\nimport { createProcessTransaction, disableProcessTransaction, getVersion, getProcess } from './api.js'\nimport { utf8ToHex } from './hex.js'\nimport { processValidation, simpleProcesssValidation } from '../types/validation.js'\nimport { CliInputParseError, DisableError, ProgramError, VersionError } from '../types/error.js'\nimport { ZodError } from 'zod'\n\nexport const defaultOptions: Polkadot.Options = {\n  API_HOST: 'localhost',\n  API_PORT: 9944,\n  USER_URI: '//Alice',\n}\n\nconst textify = (obj: Process.ProgramStep): string => {\n  return JSON.stringify(obj, (_key, val) => {\n    // convert snake case to camel case\n    if (val && typeof val === 'object') {\n      return Object.fromEntries(\n        Object.entries(val).map(([k, v]) => {\n          return [\n            [...k]\n              .map((c, i) => (k[i - 1] === '_' ? c.toUpperCase() : c))\n              .filter((c) => c != '_')\n              .join(''),\n            v,\n          ]\n        })\n      )\n    }\n    if (typeof val === 'number') return val.toString()\n    return val\n  })\n}\n\nexport const sanitizeInput = (data: string): Process.Result<{ name: string }[], CliInputParseError> => {\n  try {\n    return {\n      type: 'ok',\n      result: simpleProcesssValidation.parse(JSON.parse(data)),\n    }\n  } catch (err) {\n    if (err instanceof Error) {\n      return {\n        type: 'error',\n        error: new CliInputParseError(err),\n        message: err.message,\n      }\n    }\n    throw err\n  }\n}\n\nexport const loadProcesses = async ({\n  data,\n  options,\n  dryRun,\n  verbose,\n}: {\n  data: string\n  options: Polkadot.Options\n  dryRun?: boolean\n  verbose?: boolean\n}): Promise<Process.Response> => {\n  const parsedRes = sanitizeInput(data)\n  if (parsedRes.type === 'error') {\n    return parsedRes\n  }\n  const processes = parsedRes.result\n\n  const processTxs: Map<string, Promise<Process.ProcessResponse>> = new Map()\n  await using polkadot = await createNodeApi(options)\n  for (const process of processes) {\n    const { waitForFinalised } = await createProcess(process, dryRun, polkadot, options, verbose)\n    processTxs.set(process.name, waitForFinalised)\n  }\n  await Promise.all(processTxs.values())\n\n  const result: { [key: string]: Process.ProcessResponse } = {}\n  let successCount = 0\n  for (const [key, processTxProm] of processTxs) {\n    let response = await processTxProm\n    result[key] = response\n    if (response.type === 'ok') {\n      successCount = successCount + 1\n    }\n  }\n\n  // calculate the result and successCount\n\n  return {\n    type: 'ok',\n    result,\n    message: `Successfully loaded ${successCount}/${processes.length} processes`,\n  }\n}\n\nexport const listTransforming = (res: Process.RawPayload[], options: Process.CLIOptions) => {\n  let processes: Process.RawPayload[]\n  if (options.active) {\n    processes = res.filter(({ status }) => status === 'Enabled')\n  } else if (options.disabled) {\n    processes = res.filter(({ status }) => status === 'Disabled')\n  } else {\n    processes = res\n  }\n\n  if (options.raw) {\n    return processes.map(({ name, program, ...p }) => ({\n      name: utf8ToHex(name),\n      ...(options.verbose ? { program } : {}),\n      ...p,\n    }))\n  } else {\n    return processes.map((p) => {\n      return {\n        name: p.name,\n        version: p.version,\n        status: p.status,\n        ...(options.verbose ? { program: p.program } : {}),\n      }\n    })\n  }\n}\n\nexport const handleVerbose = (res: Process.Payload, verbose: boolean): Process.Payload => {\n  if (verbose) {\n    return res\n  }\n  const { program, ...rest } = res\n  return rest\n}\n\nexport const createProcess = async (\n  processRaw: Process.CliProcessInput,\n  dryRun: boolean = false,\n  polkadot: Polkadot.Polkadot,\n  options: Polkadot.Options = defaultOptions,\n  verbose: boolean = false\n): Promise<{\n  waitForFinalised: Promise<Process.ProcessResponse>\n}> => {\n  const handleErr = (err: unknown) => {\n    // err is basically from errors.ts or any exception\n    // process errors will contain specific messages and/or process\n    // Promise<Process.Result> is in try {} and any exception is in catch {}\n    if (err instanceof ProgramError || err instanceof VersionError || err instanceof ZodError) {\n      const result: Process.ProcessResponse = {\n        type: 'error' as 'error',\n        error: err,\n        message: err.message,\n      }\n      return {\n        waitForFinalised: Promise.resolve(result),\n      }\n    } else if (err instanceof Error) {\n      const result: Process.ProcessResponse = {\n        type: 'error' as 'error',\n        error: err,\n        message: 'An unknown error occurred',\n      }\n      return {\n        waitForFinalised: Promise.resolve(result),\n      }\n    }\n    throw err\n  }\n\n  try {\n    const { name, version, program } = processValidation.parse(processRaw)\n\n    const processId = utf8ToHex(name)\n    const currentVersion: number = await getVersion(polkadot, processId)\n    const expectedVersion: number = currentVersion + 1\n\n    if (version > expectedVersion || version < currentVersion) throw new VersionError(version, expectedVersion, name)\n\n    if (version === currentVersion) {\n      const process = await getProcess(polkadot, processId, version)\n\n      if (program.length !== process.program.length)\n        throw new ProgramError('existing: programs are different lengths', process)\n\n      if (!program.every((step, i) => textify(step) === textify(process.program[i])))\n        throw new ProgramError('existing: program steps did not match', process)\n\n      return {\n        waitForFinalised: Promise.resolve({\n          type: 'ok',\n          message: `Skipping: process ${name} is already created.`,\n          result: handleVerbose(\n            {\n              name,\n              version,\n              program,\n              status: process.status,\n            },\n            verbose\n          ),\n        }),\n      }\n    }\n\n    if (dryRun)\n      return {\n        waitForFinalised: Promise.resolve({\n          type: 'ok',\n          message: 'Dry run: transaction has not been created',\n          result: handleVerbose(\n            {\n              name,\n              version,\n              program,\n              status: 'Enabled (dry-run)',\n            },\n            verbose\n          ),\n        }),\n      }\n\n    const createProcessTx = await createProcessTransaction(polkadot, processId, program, options)\n    return {\n      waitForFinalised: createProcessTx.waitForFinal\n        .then((process) => {\n          const result: Process.ProcessResponse = {\n            type: 'ok',\n            message: `Transaction for new process ${name} has been successfully submitted`,\n            result: handleVerbose(process, verbose),\n          }\n          return result\n        })\n        .catch((err) => handleErr(err).waitForFinalised),\n    }\n  } catch (err) {\n    return handleErr(err)\n  }\n}\n\nexport const disableProcess = async (\n  name: string,\n  processVersion: number,\n  dryRun: boolean = false,\n  options: Polkadot.Options = defaultOptions\n): Promise<Process.ProcessResponse> => {\n  const processId = utf8ToHex(name)\n\n  await using polkadot = await createNodeApi(options)\n  const currentProcess: Process.Payload = await getProcess(polkadot, processId, processVersion)\n\n  if (currentProcess.status === 'Disabled') {\n    throw new DisableError(`${name} with version ${processVersion} doesn't exist or is already disabled`)\n  }\n\n  if (dryRun) {\n    return {\n      type: 'ok',\n      message: `This will DISABLE the following process ${name}`,\n      result: {\n        name,\n        version: processVersion,\n        status: 'Disabled (dry-run)',\n      },\n    }\n  }\n\n  return {\n    type: 'ok',\n    message: 'Process has been disabled',\n    result: await disableProcessTransaction(polkadot, processId, processVersion, options),\n  }\n}\n"],"names":["createNodeApi","createProcessTransaction","disableProcessTransaction","getVersion","getProcess","utf8ToHex","processValidation","simpleProcesssValidation","CliInputParseError","DisableError","ProgramError","VersionError","ZodError","defaultOptions","API_HOST","API_PORT","USER_URI","textify","obj","JSON","stringify","_key","val","Object","fromEntries","entries","map","k","v","c","i","toUpperCase","filter","join","toString","sanitizeInput","data","type","result","parse","err","Error","error","message","loadProcesses","options","dryRun","verbose","parsedRes","processes","processTxs","Map","polkadot","process","waitForFinalised","createProcess","set","name","Promise","all","values","successCount","key","processTxProm","response","length","listTransforming","res","active","status","disabled","raw","program","p","version","handleVerbose","rest","processRaw","handleErr","resolve","processId","currentVersion","expectedVersion","every","step","createProcessTx","waitForFinal","then","catch","disableProcess","processVersion","currentProcess"],"mappings":"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"}

package/build/{src/lib → lib}/types/error.js

@@ -1,26 +1,29 @@
 export class DisableError extends Error {
-    constructor(m) {
+    constructor(m){
         super(m);
         Object.setPrototypeOf(this, DisableError.prototype);
     }
 }
 export class VersionError extends Error {
-    constructor(version, expected, name) {
+    constructor(version, expected, name){
         super(`Process version ${version} is invalid. If you are trying to create a new version of process ${name} version should be ${expected}`);
         Object.setPrototypeOf(this, VersionError.prototype);
     }
 }
 export class CliInputParseError extends Error {
-    constructor(baseError) {
-        super(`Error parsing input: ${baseError.message}`);
-        this.baseError = baseError;
+    baseError;
+    constructor(baseError){
+        super(`Error parsing input: ${baseError.message}`), this.baseError = baseError;
         Object.setPrototypeOf(this, CliInputParseError.prototype);
     }
 }
 export class ProgramError extends Error {
-    constructor(m, process) {
+    process;
+    constructor(m, process){
         super(m);
         this.process = process;
         Object.setPrototypeOf(this, ProgramError.prototype);
     }
 }
+
+//# sourceMappingURL=error.js.map

package/build/lib/types/error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/types/error.ts"],"sourcesContent":["export class DisableError extends Error {\n  constructor(m: string) {\n    super(m)\n    Object.setPrototypeOf(this, DisableError.prototype)\n  }\n}\n\nexport class VersionError extends Error {\n  constructor(version: number, expected: number, name: string) {\n    super(\n      `Process version ${version} is invalid. If you are trying to create a new version of process ${name} version should be ${expected}`\n    )\n    Object.setPrototypeOf(this, VersionError.prototype)\n  }\n}\n\nexport class CliInputParseError extends Error {\n  constructor(public baseError: Error) {\n    super(`Error parsing input: ${baseError.message}`)\n    Object.setPrototypeOf(this, CliInputParseError.prototype)\n  }\n}\n\nexport class ProgramError extends Error {\n  process?: Process.Payload\n  constructor(m: string, process?: Process.Payload) {\n    super(m)\n    this.process = process\n    Object.setPrototypeOf(this, ProgramError.prototype)\n  }\n}\n"],"names":["DisableError","Error","constructor","m","Object","setPrototypeOf","prototype","VersionError","version","expected","name","CliInputParseError","baseError","message","ProgramError","process"],"mappings":"AAAA,OAAO,MAAMA,qBAAqBC;IAChCC,YAAYC,CAAS,CAAE;QACrB,KAAK,CAACA;QACNC,OAAOC,cAAc,CAAC,IAAI,EAAEL,aAAaM,SAAS;IACpD;AACF;AAEA,OAAO,MAAMC,qBAAqBN;IAChCC,YAAYM,OAAe,EAAEC,QAAgB,EAAEC,IAAY,CAAE;QAC3D,KAAK,CACH,CAAC,gBAAgB,EAAEF,QAAQ,kEAAkE,EAAEE,KAAK,mBAAmB,EAAED,UAAU;QAErIL,OAAOC,cAAc,CAAC,IAAI,EAAEE,aAAaD,SAAS;IACpD;AACF;AAEA,OAAO,MAAMK,2BAA2BV;;IACtCC,YAAY,AAAOU,SAAgB,CAAE;QACnC,KAAK,CAAC,CAAC,qBAAqB,EAAEA,UAAUC,OAAO,EAAE,QADhCD,YAAAA;QAEjBR,OAAOC,cAAc,CAAC,IAAI,EAAEM,mBAAmBL,SAAS;IAC1D;AACF;AAEA,OAAO,MAAMQ,qBAAqBb;IAChCc,QAAyB;IACzBb,YAAYC,CAAS,EAAEY,OAAyB,CAAE;QAChD,KAAK,CAACZ;QACN,IAAI,CAACY,OAAO,GAAGA;QACfX,OAAOC,cAAc,CAAC,IAAI,EAAES,aAAaR,SAAS;IACpD;AACF"}

package/build/lib/types/polkadot.d.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=polkadot.d.js.map

package/build/lib/types/polkadot.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/types/polkadot.d.ts"],"names":[],"mappings":""}

package/build/lib/types/process.d.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=process.d.js.map

package/build/lib/types/process.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/types/process.d.ts"],"names":[],"mappings":""}

package/build/lib/types/validation.js

@@ -0,0 +1,179 @@
+import { z } from 'zod';
+import { Constants } from '../process/constants.js';
+const tokenMetadataKey = z.string();
+const tokenId = z.number();
+const file = z.string();
+const metadataValue = z.union([
+    z.object({
+        File: file
+    }),
+    z.object({
+        Literal: z.string()
+    }),
+    z.object({
+        TokenId: tokenId
+    }),
+    z.object({
+        None: z.null()
+    })
+]);
+const metadataValueType = z.enum([
+    'File',
+    'Literal',
+    'TokenId',
+    'None'
+]);
+const role = z.string();
+const binaryOperator = z.enum([
+    'Identity',
+    'TransferL',
+    'TransferR',
+    'NotL',
+    'NotR',
+    'And',
+    'Nand',
+    'Or',
+    'Nor',
+    'Xor',
+    'Xnor',
+    'ImplicationL',
+    'ImplicationR',
+    'InhibitionL',
+    'InhibitionR'
+]);
+const senderHasInputRole = z.object({
+    index: z.number(),
+    role_key: role
+});
+const senderHasOutputRole = z.object({
+    index: z.number(),
+    role_key: role
+});
+const outputHasRole = z.object({
+    index: z.number(),
+    role_key: role
+});
+const outputHasMetadata = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey
+});
+const inputHasRole = z.object({
+    index: z.number(),
+    role_key: role
+});
+const inputHasMetadata = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey
+});
+const matchInputOutputRole = z.object({
+    input_index: z.number(),
+    input_role_key: role,
+    output_index: z.number(),
+    output_role_key: role
+});
+const matchInputOutputMetadataValue = z.object({
+    input_index: z.number(),
+    input_metadata_key: tokenMetadataKey,
+    output_index: z.number(),
+    output_metadata_key: tokenMetadataKey
+});
+const matchInputIdOutputMetadataValue = z.object({
+    input_index: z.number(),
+    output_index: z.number(),
+    output_metadata_key: tokenMetadataKey
+});
+const fixedNumberOfInputs = z.object({
+    num_inputs: z.number()
+});
+const fixedNumberOfOutputs = z.object({
+    num_outputs: z.number()
+});
+const fixedInputMetadataValue = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey,
+    metadata_value: metadataValue
+});
+const fixedOutputMetadataValue = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey,
+    metadata_value: metadataValue
+});
+const fixedInputMetadataValueType = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey,
+    metadata_value_type: metadataValueType
+});
+const fixedOutputMetadataValueType = z.object({
+    index: z.number(),
+    metadata_key: tokenMetadataKey,
+    metadata_value_type: metadataValueType
+});
+export const restrictionValidation = z.union([
+    z.literal('None'),
+    z.literal('Fail'),
+    z.object({
+        SenderHasInputRole: senderHasInputRole
+    }).strict(),
+    z.object({
+        SenderHasOutputRole: senderHasOutputRole
+    }).strict(),
+    z.object({
+        OutputHasRole: outputHasRole
+    }).strict(),
+    z.object({
+        OutputHasMetadata: outputHasMetadata
+    }).strict(),
+    z.object({
+        InputHasRole: inputHasRole
+    }).strict(),
+    z.object({
+        InputHasMetadata: inputHasMetadata
+    }).strict(),
+    z.object({
+        MatchInputOutputRole: matchInputOutputRole
+    }).strict(),
+    z.object({
+        MatchInputOutputMetadataValue: matchInputOutputMetadataValue
+    }).strict(),
+    z.object({
+        MatchInputIdOutputMetadataValue: matchInputIdOutputMetadataValue
+    }).strict(),
+    z.object({
+        FixedNumberOfInputs: fixedNumberOfInputs
+    }).strict(),
+    z.object({
+        FixedNumberOfOutputs: fixedNumberOfOutputs
+    }).strict(),
+    z.object({
+        FixedInputMetadataValue: fixedInputMetadataValue
+    }).strict(),
+    z.object({
+        FixedOutputMetadataValue: fixedOutputMetadataValue
+    }).strict(),
+    z.object({
+        FixedInputMetadataValueType: fixedInputMetadataValueType
+    }).strict(),
+    z.object({
+        FixedOutputMetadataValueType: fixedOutputMetadataValueType
+    }).strict()
+]);
+export const stepValidation = z.union([
+    z.object({
+        Op: binaryOperator
+    }),
+    z.object({
+        Restriction: restrictionValidation
+    })
+]);
+export const programValidation = z.array(stepValidation);
+export const processValidation = z.object({
+    name: z.string().max(Constants.PROCESS_ID_LENGTH),
+    version: z.number(),
+    program: programValidation
+});
+export const simpleProcesssValidation = z.array(z.object({
+    name: z.string()
+}).passthrough());
+export const processesValidation = z.array(processValidation);
+
+//# sourceMappingURL=validation.js.map

package/build/lib/types/validation.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/types/validation.ts"],"sourcesContent":["import { z } from 'zod'\nimport { Constants } from '../process/constants.js'\n\nconst tokenMetadataKey = z.string()\nconst tokenId = z.number()\nconst file = z.string()\nconst metadataValue = z.union([\n  z.object({ File: file }),\n  z.object({ Literal: z.string() }),\n  z.object({ TokenId: tokenId }),\n  z.object({ None: z.null() }),\n])\nconst metadataValueType = z.enum(['File', 'Literal', 'TokenId', 'None'])\nconst role = z.string()\n\nconst binaryOperator = z.enum([\n  'Identity',\n  'TransferL',\n  'TransferR',\n  'NotL',\n  'NotR',\n  'And',\n  'Nand',\n  'Or',\n  'Nor',\n  'Xor',\n  'Xnor',\n  'ImplicationL',\n  'ImplicationR',\n  'InhibitionL',\n  'InhibitionR',\n])\n\nconst senderHasInputRole = z.object({\n  index: z.number(),\n  role_key: role,\n})\n\nconst senderHasOutputRole = z.object({\n  index: z.number(),\n  role_key: role,\n})\n\nconst outputHasRole = z.object({\n  index: z.number(),\n  role_key: role,\n})\n\nconst outputHasMetadata = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n})\n\nconst inputHasRole = z.object({\n  index: z.number(),\n  role_key: role,\n})\n\nconst inputHasMetadata = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n})\n\nconst matchInputOutputRole = z.object({\n  input_index: z.number(),\n  input_role_key: role,\n  output_index: z.number(),\n  output_role_key: role,\n})\n\nconst matchInputOutputMetadataValue = z.object({\n  input_index: z.number(),\n  input_metadata_key: tokenMetadataKey,\n  output_index: z.number(),\n  output_metadata_key: tokenMetadataKey,\n})\n\nconst matchInputIdOutputMetadataValue = z.object({\n  input_index: z.number(),\n  output_index: z.number(),\n  output_metadata_key: tokenMetadataKey,\n})\n\nconst fixedNumberOfInputs = z.object({\n  num_inputs: z.number(),\n})\n\nconst fixedNumberOfOutputs = z.object({\n  num_outputs: z.number(),\n})\n\nconst fixedInputMetadataValue = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n  metadata_value: metadataValue,\n})\n\nconst fixedOutputMetadataValue = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n  metadata_value: metadataValue,\n})\n\nconst fixedInputMetadataValueType = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n  metadata_value_type: metadataValueType,\n})\n\nconst fixedOutputMetadataValueType = z.object({\n  index: z.number(),\n  metadata_key: tokenMetadataKey,\n  metadata_value_type: metadataValueType,\n})\n\nexport const restrictionValidation = z.union([\n  z.literal('None'),\n  z.literal('Fail'),\n  z.object({ SenderHasInputRole: senderHasInputRole }).strict(),\n  z.object({ SenderHasOutputRole: senderHasOutputRole }).strict(),\n  z.object({ OutputHasRole: outputHasRole }).strict(),\n  z.object({ OutputHasMetadata: outputHasMetadata }).strict(),\n  z.object({ InputHasRole: inputHasRole }).strict(),\n  z.object({ InputHasMetadata: inputHasMetadata }).strict(),\n  z.object({ MatchInputOutputRole: matchInputOutputRole }).strict(),\n  z.object({ MatchInputOutputMetadataValue: matchInputOutputMetadataValue }).strict(),\n  z.object({ MatchInputIdOutputMetadataValue: matchInputIdOutputMetadataValue }).strict(),\n  z.object({ FixedNumberOfInputs: fixedNumberOfInputs }).strict(),\n  z.object({ FixedNumberOfOutputs: fixedNumberOfOutputs }).strict(),\n  z.object({ FixedInputMetadataValue: fixedInputMetadataValue }).strict(),\n  z.object({ FixedOutputMetadataValue: fixedOutputMetadataValue }).strict(),\n  z.object({ FixedInputMetadataValueType: fixedInputMetadataValueType }).strict(),\n  z.object({ FixedOutputMetadataValueType: fixedOutputMetadataValueType }).strict(),\n])\n\nexport const stepValidation = z.union([\n  z.object({ Op: binaryOperator }),\n  z.object({ Restriction: restrictionValidation }),\n])\n\nexport const programValidation = z.array(stepValidation)\n\nexport const processValidation = z.object({\n  name: z.string().max(Constants.PROCESS_ID_LENGTH),\n  version: z.number(),\n  program: programValidation,\n})\n\nexport const simpleProcesssValidation = z.array(z.object({ name: z.string() }).passthrough())\n\nexport const processesValidation = z.array(processValidation)\n\nexport type ValidationRestriction = z.infer<typeof restrictionValidation>\nexport type ValidationProgramStep = z.infer<typeof stepValidation>\nexport type ValidationProgram = z.infer<typeof programValidation>\nexport type ValidationProcess = z.infer<typeof processValidation>\nexport type ValidationProcesses = z.infer<typeof processesValidation>\n"],"names":["z","Constants","tokenMetadataKey","string","tokenId","number","file","metadataValue","union","object","File","Literal","TokenId","None","null","metadataValueType","enum","role","binaryOperator","senderHasInputRole","index","role_key","senderHasOutputRole","outputHasRole","outputHasMetadata","metadata_key","inputHasRole","inputHasMetadata","matchInputOutputRole","input_index","input_role_key","output_index","output_role_key","matchInputOutputMetadataValue","input_metadata_key","output_metadata_key","matchInputIdOutputMetadataValue","fixedNumberOfInputs","num_inputs","fixedNumberOfOutputs","num_outputs","fixedInputMetadataValue","metadata_value","fixedOutputMetadataValue","fixedInputMetadataValueType","metadata_value_type","fixedOutputMetadataValueType","restrictionValidation","literal","SenderHasInputRole","strict","SenderHasOutputRole","OutputHasRole","OutputHasMetadata","InputHasRole","InputHasMetadata","MatchInputOutputRole","MatchInputOutputMetadataValue","MatchInputIdOutputMetadataValue","FixedNumberOfInputs","FixedNumberOfOutputs","FixedInputMetadataValue","FixedOutputMetadataValue","FixedInputMetadataValueType","FixedOutputMetadataValueType","stepValidation","Op","Restriction","programValidation","array","processValidation","name","max","PROCESS_ID_LENGTH","version","program","simpleProcesssValidation","passthrough","processesValidation"],"mappings":"AAAA,SAASA,CAAC,QAAQ,MAAK;AACvB,SAASC,SAAS,QAAQ,0BAAyB;AAEnD,MAAMC,mBAAmBF,EAAEG,MAAM;AACjC,MAAMC,UAAUJ,EAAEK,MAAM;AACxB,MAAMC,OAAON,EAAEG,MAAM;AACrB,MAAMI,gBAAgBP,EAAEQ,KAAK,CAAC;IAC5BR,EAAES,MAAM,CAAC;QAAEC,MAAMJ;IAAK;IACtBN,EAAES,MAAM,CAAC;QAAEE,SAASX,EAAEG,MAAM;IAAG;IAC/BH,EAAES,MAAM,CAAC;QAAEG,SAASR;IAAQ;IAC5BJ,EAAES,MAAM,CAAC;QAAEI,MAAMb,EAAEc,IAAI;IAAG;CAC3B;AACD,MAAMC,oBAAoBf,EAAEgB,IAAI,CAAC;IAAC;IAAQ;IAAW;IAAW;CAAO;AACvE,MAAMC,OAAOjB,EAAEG,MAAM;AAErB,MAAMe,iBAAiBlB,EAAEgB,IAAI,CAAC;IAC5B;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAED,MAAMG,qBAAqBnB,EAAES,MAAM,CAAC;IAClCW,OAAOpB,EAAEK,MAAM;IACfgB,UAAUJ;AACZ;AAEA,MAAMK,sBAAsBtB,EAAES,MAAM,CAAC;IACnCW,OAAOpB,EAAEK,MAAM;IACfgB,UAAUJ;AACZ;AAEA,MAAMM,gBAAgBvB,EAAES,MAAM,CAAC;IAC7BW,OAAOpB,EAAEK,MAAM;IACfgB,UAAUJ;AACZ;AAEA,MAAMO,oBAAoBxB,EAAES,MAAM,CAAC;IACjCW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;AAChB;AAEA,MAAMwB,eAAe1B,EAAES,MAAM,CAAC;IAC5BW,OAAOpB,EAAEK,MAAM;IACfgB,UAAUJ;AACZ;AAEA,MAAMU,mBAAmB3B,EAAES,MAAM,CAAC;IAChCW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;AAChB;AAEA,MAAM0B,uBAAuB5B,EAAES,MAAM,CAAC;IACpCoB,aAAa7B,EAAEK,MAAM;IACrByB,gBAAgBb;IAChBc,cAAc/B,EAAEK,MAAM;IACtB2B,iBAAiBf;AACnB;AAEA,MAAMgB,gCAAgCjC,EAAES,MAAM,CAAC;IAC7CoB,aAAa7B,EAAEK,MAAM;IACrB6B,oBAAoBhC;IACpB6B,cAAc/B,EAAEK,MAAM;IACtB8B,qBAAqBjC;AACvB;AAEA,MAAMkC,kCAAkCpC,EAAES,MAAM,CAAC;IAC/CoB,aAAa7B,EAAEK,MAAM;IACrB0B,cAAc/B,EAAEK,MAAM;IACtB8B,qBAAqBjC;AACvB;AAEA,MAAMmC,sBAAsBrC,EAAES,MAAM,CAAC;IACnC6B,YAAYtC,EAAEK,MAAM;AACtB;AAEA,MAAMkC,uBAAuBvC,EAAES,MAAM,CAAC;IACpC+B,aAAaxC,EAAEK,MAAM;AACvB;AAEA,MAAMoC,0BAA0BzC,EAAES,MAAM,CAAC;IACvCW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;IACdwC,gBAAgBnC;AAClB;AAEA,MAAMoC,2BAA2B3C,EAAES,MAAM,CAAC;IACxCW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;IACdwC,gBAAgBnC;AAClB;AAEA,MAAMqC,8BAA8B5C,EAAES,MAAM,CAAC;IAC3CW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;IACd2C,qBAAqB9B;AACvB;AAEA,MAAM+B,+BAA+B9C,EAAES,MAAM,CAAC;IAC5CW,OAAOpB,EAAEK,MAAM;IACfoB,cAAcvB;IACd2C,qBAAqB9B;AACvB;AAEA,OAAO,MAAMgC,wBAAwB/C,EAAEQ,KAAK,CAAC;IAC3CR,EAAEgD,OAAO,CAAC;IACVhD,EAAEgD,OAAO,CAAC;IACVhD,EAAES,MAAM,CAAC;QAAEwC,oBAAoB9B;IAAmB,GAAG+B,MAAM;IAC3DlD,EAAES,MAAM,CAAC;QAAE0C,qBAAqB7B;IAAoB,GAAG4B,MAAM;IAC7DlD,EAAES,MAAM,CAAC;QAAE2C,eAAe7B;IAAc,GAAG2B,MAAM;IACjDlD,EAAES,MAAM,CAAC;QAAE4C,mBAAmB7B;IAAkB,GAAG0B,MAAM;IACzDlD,EAAES,MAAM,CAAC;QAAE6C,cAAc5B;IAAa,GAAGwB,MAAM;IAC/ClD,EAAES,MAAM,CAAC;QAAE8C,kBAAkB5B;IAAiB,GAAGuB,MAAM;IACvDlD,EAAES,MAAM,CAAC;QAAE+C,sBAAsB5B;IAAqB,GAAGsB,MAAM;IAC/DlD,EAAES,MAAM,CAAC;QAAEgD,+BAA+BxB;IAA8B,GAAGiB,MAAM;IACjFlD,EAAES,MAAM,CAAC;QAAEiD,iCAAiCtB;IAAgC,GAAGc,MAAM;IACrFlD,EAAES,MAAM,CAAC;QAAEkD,qBAAqBtB;IAAoB,GAAGa,MAAM;IAC7DlD,EAAES,MAAM,CAAC;QAAEmD,sBAAsBrB;IAAqB,GAAGW,MAAM;IAC/DlD,EAAES,MAAM,CAAC;QAAEoD,yBAAyBpB;IAAwB,GAAGS,MAAM;IACrElD,EAAES,MAAM,CAAC;QAAEqD,0BAA0BnB;IAAyB,GAAGO,MAAM;IACvElD,EAAES,MAAM,CAAC;QAAEsD,6BAA6BnB;IAA4B,GAAGM,MAAM;IAC7ElD,EAAES,MAAM,CAAC;QAAEuD,8BAA8BlB;IAA6B,GAAGI,MAAM;CAChF,EAAC;AAEF,OAAO,MAAMe,iBAAiBjE,EAAEQ,KAAK,CAAC;IACpCR,EAAES,MAAM,CAAC;QAAEyD,IAAIhD;IAAe;IAC9BlB,EAAES,MAAM,CAAC;QAAE0D,aAAapB;IAAsB;CAC/C,EAAC;AAEF,OAAO,MAAMqB,oBAAoBpE,EAAEqE,KAAK,CAACJ,gBAAe;AAExD,OAAO,MAAMK,oBAAoBtE,EAAES,MAAM,CAAC;IACxC8D,MAAMvE,EAAEG,MAAM,GAAGqE,GAAG,CAACvE,UAAUwE,iBAAiB;IAChDC,SAAS1E,EAAEK,MAAM;IACjBsE,SAASP;AACX,GAAE;AAEF,OAAO,MAAMQ,2BAA2B5E,EAAEqE,KAAK,CAACrE,EAAES,MAAM,CAAC;IAAE8D,MAAMvE,EAAEG,MAAM;AAAG,GAAG0E,WAAW,IAAG;AAE7F,OAAO,MAAMC,sBAAsB9E,EAAEqE,KAAK,CAACC,mBAAkB"}

package/build/lib/utils/polkadot.js

@@ -0,0 +1,26 @@
+import { ApiPromise, WsProvider, Keyring } from '@polkadot/api';
+export const createNodeApi = async (options)=>{
+    const provider = new WsProvider(`ws://${options.API_HOST}:${options.API_PORT}`);
+    const api = new ApiPromise({
+        provider
+    });
+    api.isReadyOrError.catch(()=>{}) // prevent unhandled promise rejection errors
+    ;
+    await api.isReady;
+    api.on('error', (err)=>{
+        const msg = err.message || JSON.stringify(err);
+        console.log(`Error from substrate node connection. Error was ${msg}`);
+        return msg;
+    });
+    return {
+        api,
+        keyring: new Keyring({
+            type: 'sr25519'
+        }),
+        [Symbol.asyncDispose]: async ()=>{
+            await api.disconnect();
+        }
+    };
+};
+
+//# sourceMappingURL=polkadot.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/utils/polkadot.ts"],"sourcesContent":["import { ApiPromise, WsProvider, Keyring } from '@polkadot/api'\n\nexport const createNodeApi = async (options: Polkadot.Options) => {\n  const provider = new WsProvider(`ws://${options.API_HOST}:${options.API_PORT}`)\n  const api = new ApiPromise({ provider })\n\n  api.isReadyOrError.catch(() => {}) // prevent unhandled promise rejection errors\n\n  await api.isReady\n\n  api.on('error', (err: { message?: string }): string => {\n    const msg = err.message || JSON.stringify(err)\n    console.log(`Error from substrate node connection. Error was ${msg}`)\n\n    return msg\n  })\n\n  return {\n    api,\n    keyring: new Keyring({ type: 'sr25519' }),\n    [Symbol.asyncDispose]: async () => {\n      await api.disconnect()\n    },\n  }\n}\n"],"names":["ApiPromise","WsProvider","Keyring","createNodeApi","options","provider","API_HOST","API_PORT","api","isReadyOrError","catch","isReady","on","err","msg","message","JSON","stringify","console","log","keyring","type","Symbol","asyncDispose","disconnect"],"mappings":"AAAA,SAASA,UAAU,EAAEC,UAAU,EAAEC,OAAO,QAAQ,gBAAe;AAE/D,OAAO,MAAMC,gBAAgB,OAAOC;IAClC,MAAMC,WAAW,IAAIJ,WAAW,CAAC,KAAK,EAAEG,QAAQE,QAAQ,CAAC,CAAC,EAAEF,QAAQG,QAAQ,EAAE;IAC9E,MAAMC,MAAM,IAAIR,WAAW;QAAEK;IAAS;IAEtCG,IAAIC,cAAc,CAACC,KAAK,CAAC,KAAO,GAAG,6CAA6C;;IAEhF,MAAMF,IAAIG,OAAO;IAEjBH,IAAII,EAAE,CAAC,SAAS,CAACC;QACf,MAAMC,MAAMD,IAAIE,OAAO,IAAIC,KAAKC,SAAS,CAACJ;QAC1CK,QAAQC,GAAG,CAAC,CAAC,gDAAgD,EAAEL,KAAK;QAEpE,OAAOA;IACT;IAEA,OAAO;QACLN;QACAY,SAAS,IAAIlB,QAAQ;YAAEmB,MAAM;QAAU;QACvC,CAACC,OAAOC,YAAY,CAAC,EAAE;YACrB,MAAMf,IAAIgB,UAAU;QACtB;IACF;AACF,EAAC"}

package/build/version.js

@@ -0,0 +1,5 @@
+import packageJson from '../package.json';
+const { version } = packageJson;
+export default version;
+
+//# sourceMappingURL=version.js.map

package/build/version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/version.ts"],"sourcesContent":["import packageJson from '../package.json' assert { type: 'json' }\nconst { version } = packageJson\nexport default version"],"names":["packageJson","version"],"mappings":"AAAA,OAAOA,iBAAiB,kBAAyC;AACjE,MAAM,EAAEC,OAAO,EAAE,GAAGD;AACpB,eAAeC,QAAO"}