@cef-ebsi/cli 1.3.1 → 1.4.0

package/dist/app.js

@@ -1,18 +1,17 @@
-/* eslint-disable no-use-before-define, @typescript-eslint/no-use-before-define */
-import { URL } from "node:url";
-import { ethers } from "ethers";
 import { EbsiWallet } from "@cef-ebsi/wallet-lib";
-import lodashSet from "lodash.set";
-import { calculateJwkThumbprint } from "jose";
-import fs from "fs";
-import path from "path";
+import { ethers } from "ethers";
 import Joi from "joi";
-import { loadConfig, } from "./config.js";
-import * as utils from "./utils/index.js";
+import { calculateJwkThumbprint } from "jose";
+import lodashSet from "lodash.set";
+import fs from "node:fs";
+import path from "node:path";
+import { URL } from "node:url";
 import { buildParam } from "./buildParam/index.js";
-import { jsonrpcBody, paramSignedTransaction, parseLine, prefixWith0x, HardwareWallet, } from "./utils/index.js";
+import { authorisation, compute, conformance, hardwarewallet, ledger, tnl, view, waitToBeMined, } from "./commands/index.js";
+import { loadConfig, } from "./config.js";
 import { Client } from "./utils/Client.js";
-import { authorisationV4, compute, view, conformanceV3, ledgerV4, waitToBeMined, hardwarewallet, tnl, } from "./commands/index.js";
+import * as utils from "./utils/index.js";
+import { HardwareWallet, jsonrpcBody, paramSignedTransaction, parseLine, prefixWith0x, } from "./utils/index.js";
 let config = loadConfig();
 let client = new Client();
 let transactionInfo;
@@ -24,16 +23,198 @@ const rtVars = {}; // runtime variables
 const algSchema = Joi.string()
     .valid("ES256K", "ES256", "RS256", "EdDSA")
     .required();
-async function setVar(key, value, printVar = true) {
-    lodashSet(rtVars, key, value);
-    if (key.startsWith("user.")) {
-        await execCommand("using user user");
-        return;
+export async function execCommand(command, printCommand = false) {
+    if (printCommand)
+        console.log(`==> ${command}`);
+    const parts = parseLine(command);
+    let varName = "";
+    if (parts.length === 0)
+        return 0;
+    if (typeof parts[0] === "string" && parts[0].includes(":")) {
+        varName = parts[0].replace(":", "");
+        parts.shift();
+    }
+    const [part0, part1] = parts;
+    const parts2 = parts.slice(2);
+    const method = part0;
+    const word1 = part1;
+    Joi.assert(method, Joi.string());
+    // APIs linked to smart contracts
+    if (["did", "timestamp", "tir", "tnt", "tpr", "tsr"].includes(method)) {
+        Joi.assert(word1, Joi.string());
+        const response = await smartContractApi(method, word1, ...parts2);
+        if (varName)
+            await setVar(varName, response);
+        return response;
+    }
+    const schemaStrings = Joi.array().items(Joi.string());
+    const context = {
+        client,
+        config,
+        httpOpts,
+        rtVars,
+        token,
+        transactionInfo,
+    };
+    // Other APIs and configurations
+    switch (method) {
+        case "authorisation": {
+            Joi.assert(word1, Joi.string());
+            Joi.assert(parts2, schemaStrings);
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await authorisation(word1, inputs, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "compute": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await compute(word1, inputs, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "conformance": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await conformance(word1, inputs, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "domain": {
+            Joi.assert(word1, Joi.string());
+            await setDomain(word1);
+            return 0;
+        }
+        case "env": {
+            Joi.assert(word1, Joi.string().optional());
+            const input = readValue(word1);
+            await environment(input);
+            return 0;
+        }
+        case "exit": {
+            return process.exit(0);
+        }
+        case "export": {
+            let data = readValue(word1);
+            const filename = readValue(parts2[0]);
+            if (typeof data === "object") {
+                data = JSON.stringify(data, null, 2);
+            }
+            const absolutePath = path.isAbsolute(filename)
+                ? filename
+                : path.join(`${process.cwd()}`, filename);
+            fs.writeFileSync(filename, data);
+            utils.yellow(`file saved at ${absolutePath}`);
+            return undefined;
+        }
+        case "fs": {
+            Joi.assert(word1, Joi.string());
+            const response = fileSystem(word1, ...parts2);
+            console.log(response);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "get": {
+            Joi.assert(word1, Joi.string());
+            const input = readValue(word1);
+            const response = await utils.httpCall.get(input, context.httpOpts);
+            if (varName)
+                await setVar(varName, response.data);
+            return response.data;
+        }
+        case "hardwarewallet":
+        case "hw": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => {
+                if (word1 === "setpin")
+                    return p;
+                return readValue(p);
+            });
+            const response = await hardwarewallet(word1, inputs, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "ledger": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await ledger(word1, inputs, false, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "load": {
+            const filename = readValue(word1);
+            const data = readFile(filename);
+            let response;
+            try {
+                response = JSON.parse(data);
+            }
+            catch {
+                response = data;
+            }
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "proxyledger": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await ledger(word1, inputs, true, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "run": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await run(word1, inputs);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "set": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            let value = inputs[0];
+            if (inputs.length > 1) {
+                Joi.assert(inputs, schemaStrings);
+                value = inputs.join("");
+            }
+            await setVar(word1, value);
+            return value;
+        }
+        case "tnl": {
+            Joi.assert(word1, Joi.string());
+            const inputs = parts2.map((p) => readValue(p));
+            const response = await tnl(word1, inputs, context);
+            if (varName)
+                await setVar(varName, response);
+            return response;
+        }
+        case "using": {
+            Joi.assert(word1, Joi.string());
+            const user = await using(word1, ...parts2);
+            return user;
+        }
+        case "version": {
+            Joi.assert(word1, Joi.string().optional());
+            const input = readValue(word1);
+            await setVersionApis(input);
+            return 0;
+        }
+        case "view": {
+            Joi.assert(word1, Joi.string());
+            return view([readValue(word1)], context);
+        }
+        default: {
+            throw new Error(`Invalid method '${method}'`);
+        }
     }
-    if (!printVar)
-        return;
-    utils.cyanBold(`Value saved in '${key}':`);
-    utils.cyan(value);
 }
 export async function initConfigVars() {
     await setVar("domain", config.domain, false);
@@ -47,41 +228,246 @@ export async function initConfigVars() {
     await setVar("ledgerUrl", config.api.ledger.url, false);
     await setVar("authorisationUrl", config.api.authorisation.url, false);
 }
-function updateHttpOpts() {
-    const conformanceId = readValue("conformanceId", true);
-    httpOpts = {
-        headers: {
-            ...(token && {
-                authorization: `Bearer ${token}`,
-            }),
-            ...(conformanceId && { conformance: conformanceId }),
-        },
-    };
+export async function main() {
+    await initConfigVars();
+    while (true) {
+        const command = await utils.askQuestion("==> ");
+        try {
+            await execCommand(command);
+        }
+        catch (error) {
+            utils.red(error.stack);
+        }
+    }
 }
-function readValue(input, required = false) {
-    if (!input || typeof input !== "string")
-        return input;
-    const parts = input.split(".");
-    let fieldName = parts[0];
-    if (typeof rtVars[fieldName] === "undefined") {
-        if (required)
-            return undefined;
-        return input;
+async function environment(env) {
+    if (env) {
+        config = loadConfig(env, config.versionApis);
+        await initConfigVars();
+        utils.yellow(`Environment ${env} loaded`);
     }
-    let i = 0;
-    let obj = rtVars;
-    while (i < parts.length - 1) {
-        obj = obj[fieldName];
-        i += 1;
-        fieldName = parts[i];
+    else {
+        utils.yellow(`Current environment: ${config.env}`);
     }
-    return obj[fieldName];
+    const { api, contractAddresses, domain, env: envConfig } = config;
+    utils.yellow({
+        contractAddresses,
+        domain,
+        env: envConfig,
+        urls: Object.keys(api).map((name) => api[name].url),
+        version: config.versionApis,
+    });
 }
-function urlPath(inputs) {
+function fileSystem(method, ...params) {
+    switch (method) {
+        case "readBinaryFile": {
+            const [filename] = params;
+            Joi.assert(filename, Joi.string());
+            return fs.readFileSync(filename);
+        }
+        case "writeBinaryFile": {
+            const filename = readValue(params[0]);
+            const data = readValue(params[1]);
+            Joi.assert(filename, Joi.string());
+            fs.writeFileSync(filename, data);
+            return 0;
+        }
+        default: {
+            throw new Error(`Invalid method '${method}'`);
+        }
+    }
+}
+function readFile(filename) {
+    try {
+        // get the file from the working directory
+        return fs.readFileSync(filename, "utf8");
+    }
+    catch {
+        // otherwise get the file from the internal scripts of the CLI tool
+        try {
+            return fs.readFileSync(new URL(`scripts/${filename}`, import.meta.url), "utf8");
+        }
+        catch {
+            throw new Error(`Can't open script ${filename}`);
+        }
+    }
+}
+function readValue(input, required = false) {
+    if (!input || typeof input !== "string")
+        return input;
+    const parts = input.split(".");
+    let fieldName = parts[0];
+    if (rtVars[fieldName] === undefined) {
+        if (required)
+            return undefined;
+        return input;
+    }
+    let i = 0;
+    let obj = rtVars;
+    while (i < parts.length - 1) {
+        obj = obj[fieldName];
+        i += 1;
+        fieldName = parts[i];
+    }
+    return obj[fieldName];
+}
+async function run(filename, inputs = []) {
+    const filedata = readFile(filename);
+    const lines = filedata.split(/\r?\n/);
+    let response;
+    for (const [i, line_] of lines.entries()) {
+        let line = line_.trim();
+        if (line.length > 0 && !line.startsWith("#")) {
+            for (const [j, input] of inputs.entries()) {
+                const param = typeof input === "string" ? input : JSON.stringify(input);
+                line = line.replaceAll(new RegExp(`\\$${j + 1}`, "g"), param);
+            }
+            try {
+                response = await execCommand(line, true);
+            }
+            catch (error) {
+                utils.red(error.stack);
+                throw new Error(`Error in line ${i + 1}: ${error.message}`);
+            }
+        }
+        else {
+            console.log(line);
+        }
+    }
+    return response;
+}
+async function setDomain(dom) {
+    if (dom) {
+        for (const apiName of Object.keys(config.api)) {
+            config.api[apiName].url = config.api[apiName].url.replace(config.domain, dom);
+        }
+        config.domain = dom;
+        await setVar("domain", config.domain);
+    }
+    utils.yellow(`Current domain: ${config.domain}`);
+}
+async function setVar(key, value, printVar = true) {
+    lodashSet(rtVars, key, value);
+    if (key.startsWith("user.")) {
+        await execCommand("using user user");
+        return;
+    }
+    if (!printVar)
+        return;
+    utils.cyanBold(`Value saved in '${key}':`);
+    utils.cyan(value);
+}
+async function setVersionApis(version) {
+    if (version) {
+        config = loadConfig(config.env, version);
+        await initConfigVars();
+        utils.yellow(`Version ${config.versionApis} loaded`);
+    }
+    else {
+        utils.yellow(`Current version: ${config.versionApis}`);
+    }
+    const { api, contractAddresses, domain, env: envConfig } = config;
+    utils.yellow({
+        contractAddresses,
+        domain,
+        env: envConfig,
+        urls: Object.keys(api).map((name) => api[name].url),
+        version: config.versionApis,
+    });
+}
+async function smartContractApi(contract, method, ...inputs) {
+    const apiUrl = config.api[contract].url;
+    if (method === "get") {
+        const response = await utils.httpCall.get(`${apiUrl}${urlPath(inputs)}`, httpOpts);
+        return response.data;
+    }
+    if (method === "head") {
+        const response = await utils.httpCall.head(`${apiUrl}${urlPath(inputs)}`, httpOpts);
+        return response.data;
+    }
+    const url = `${apiUrl}/jsonrpc`;
+    if (method === "sendSignedTransaction") {
+        const unsignedTransaction = readValue(inputs[0]);
+        const sgnTx = readValue(inputs[1]);
+        Joi.assert(unsignedTransaction, Joi.object());
+        Joi.assert(sgnTx, Joi.string());
+        const bodySend = jsonrpcBody(method, [
+            paramSignedTransaction(unsignedTransaction, sgnTx),
+        ]);
+        const response = await utils.httpCall.post(url, bodySend, httpOpts);
+        // use ledger proxy is besu provider is defined
+        const context = {
+            client,
+            config,
+            httpOpts,
+            rtVars,
+            token,
+            transactionInfo,
+        };
+        const useProxy = !!config.besuProvider;
+        transactionInfo.txId = response.data.result;
+        transactionInfo.receipt = await waitToBeMined(response.data.result, useProxy, context);
+        return transactionInfo.receipt;
+    }
+    if (!method.startsWith("build-")) {
+        const inputsStr = inputs
+            .map((input) => typeof input === "string" ? input : JSON.stringify(input))
+            .join(" ");
+        const uTx = await execCommand(`${contract} build-${method} ${inputsStr}`, true);
+        const sgnTx = await execCommand(`compute signTransaction ${JSON.stringify(uTx)}`, true);
+        await execCommand(`${contract} sendSignedTransaction ${JSON.stringify(uTx)} ${sgnTx}`, true);
+        const txInfo = await execCommand("view transactionInfo", true);
+        return txInfo;
+    }
+    let m = method.replace("build-", "");
+    const build = await buildParam(contract, m, client, inputs.map((input) => readValue(input)), config.versionApis);
+    if (build.method)
+        m = build.method.slice(0, Math.max(0, build.method.indexOf("(")));
+    const param = {
+        from: client.ethWallet.address,
+        ...build.param,
+    };
+    const body = jsonrpcBody(m, [param]);
+    const response = await utils.httpCall.post(url, body, httpOpts);
+    utils.yellow(build.info.title);
+    utils.yellow(build.info.data);
+    transactionInfo = {
+        build,
+        contract,
+        method: m,
+    };
+    return response.data.result;
+}
+function updateHttpOpts() {
+    const conformanceId = readValue("conformanceId", true);
+    httpOpts = {
+        headers: {
+            ...(token && {
+                authorization: `Bearer ${token}`,
+            }),
+            ...(conformanceId && { conformance: conformanceId }),
+        },
+    };
+}
+function urlPath(inputs) {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string
     return inputs.map((input) => readValue(input)).join("");
 }
 async function using(method, ...params) {
     switch (method) {
+        case "ethuser": {
+            if (params[0] === "null") {
+                const hw = client.hardwareWallet;
+                client = new Client();
+                client.hardwareWallet = hw;
+                await setVar("user", client.toJSON(), false);
+                utils.yellow("User removed");
+                return client;
+            }
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            await execCommand(`using user ES256K ${params.join(" ")}`, true);
+            return client;
+        }
         case "token": {
             token = params[0] === "empty" ? null : readValue(params[0]);
             updateHttpOpts();
@@ -97,7 +483,7 @@ async function using(method, ...params) {
                 client.hardwareWallet = hw;
                 client.did = existingUser.did;
                 client.didVersion = existingUser.didVersion;
-                client.privateKeyHex = existingUser.privateKeyHex;
+                client.keys = existingUser.keys;
                 client.clientId = existingUser.clientId;
                 client.accreditationUrl = existingUser.accreditationUrl;
                 if (existingUser.accreditationUrl) {
@@ -105,10 +491,9 @@ async function using(method, ...params) {
                 }
                 client.proxyId = existingUser.proxyId;
                 client.issuerState = existingUser.issuerState;
-                if (existingUser.privateKeyHex) {
-                    client.ethWallet = new ethers.Wallet(existingUser.privateKeyHex);
+                if (existingUser.keys?.ES256K) {
+                    client.ethWallet = new ethers.Wallet(existingUser.keys.ES256K.privateKeyHex);
                 }
-                client.keys = existingUser.keys;
                 await setVar("user", client.toJSON(), false);
                 await execCommand("view user", false);
                 return client;
@@ -149,15 +534,14 @@ async function using(method, ...params) {
                 }
                 else {
                     client.ethWallet = new ethers.Wallet(utils.encodePrivateKey({
-                        key: privateKey,
                         format: "hex",
+                        key: privateKey,
                     }));
                 }
-                client.privateKeyHex = client.ethWallet.privateKey;
                 const privateKeyJwk = utils.encodePrivateKey({
-                    key: client.ethWallet.privateKey,
                     alg,
                     format: "jwk",
+                    key: client.ethWallet.privateKey,
                 });
                 client.setJwk(alg, privateKeyJwk);
             }
@@ -166,24 +550,24 @@ async function using(method, ...params) {
                     client.hardwareWallet = new HardwareWallet(config.openSClib);
                 const publicKeyJwk = client.hardwareWallet.getPublicKey();
                 const publicKeyPem = utils.encodePublicKey({
-                    key: publicKeyJwk,
                     alg,
                     format: "pem",
+                    key: publicKeyJwk,
                 });
                 client.keys.ES256 = {
                     id: "",
+                    isHardwareWallet: true,
                     kid: "",
                     privateKeyJwk: undefined,
                     publicKeyJwk,
                     publicKeyPem,
-                    isHardwareWallet: true,
                 };
             }
             else if (alg === "ES256" && typeof privateKey === "string") {
                 const privateKeyJwk = utils.encodePrivateKey({
-                    key: privateKey,
                     alg,
                     format: "jwk",
+                    key: privateKey,
                 });
                 client.setJwk(alg, privateKeyJwk);
             }
@@ -215,8 +599,9 @@ async function using(method, ...params) {
                     }
                     break;
                 }
-                default:
+                default: {
                     throw new Error("did method must be 'did1' or 'did2'");
+                }
             }
             client.keys[alg].id = verificationMethodId;
             client.keys[alg].kid = `${client.did}#${verificationMethodId}`;
@@ -224,392 +609,8 @@ async function using(method, ...params) {
             await execCommand("view user", false);
             return client;
         }
-        case "ethuser": {
-            if (params[0] === "null") {
-                const hw = client.hardwareWallet;
-                client = new Client();
-                client.hardwareWallet = hw;
-                await setVar("user", client.toJSON(), false);
-                utils.yellow("User removed");
-                return client;
-            }
-            await execCommand(`using user ES256K ${params.join(" ")}`, true);
-            return client;
-        }
-        default:
+        default: {
             throw new Error(`Invalid subject '${method}'`);
-    }
-}
-async function smartContractApi(contract, method, ...inputs) {
-    const apiUrl = config.api[contract].url;
-    if (method === "get") {
-        const response = await utils.httpCall.get(`${apiUrl}${urlPath(inputs)}`, httpOpts);
-        return response.data;
-    }
-    if (method === "head") {
-        const response = await utils.httpCall.head(`${apiUrl}${urlPath(inputs)}`, httpOpts);
-        return response.data;
-    }
-    const url = `${apiUrl}/jsonrpc`;
-    if (method === "sendSignedTransaction") {
-        const unsignedTransaction = readValue(inputs[0]);
-        const sgnTx = readValue(inputs[1]);
-        Joi.assert(unsignedTransaction, Joi.object());
-        Joi.assert(sgnTx, Joi.string());
-        const bodySend = jsonrpcBody(method, [
-            paramSignedTransaction(unsignedTransaction, sgnTx),
-        ]);
-        const response = await utils.httpCall.post(url, bodySend, httpOpts);
-        // use ledger proxy is besu provider is defined
-        const context = {
-            config,
-            httpOpts,
-            client,
-            rtVars,
-            transactionInfo,
-            token,
-        };
-        const useProxy = !!config.besuProvider;
-        transactionInfo.txId = response.data.result;
-        transactionInfo.receipt = await waitToBeMined(response.data.result, useProxy, context);
-        return transactionInfo.receipt;
-    }
-    if (!method.startsWith("build-")) {
-        const inputsStr = inputs
-            .map((input) => typeof input === "string" ? input : JSON.stringify(input))
-            .join(" ");
-        const uTx = await execCommand(`${contract} build-${method} ${inputsStr}`, true);
-        const sgnTx = await execCommand(`compute signTransaction ${JSON.stringify(uTx)}`, true);
-        await execCommand(`${contract} sendSignedTransaction ${JSON.stringify(uTx)} ${sgnTx}`, true);
-        const txInfo = await execCommand("view transactionInfo", true);
-        return txInfo;
-    }
-    let m = method.replace("build-", "");
-    const build = await buildParam(contract, m, client, inputs.map((input) => readValue(input)), config.versionApis);
-    if (build.method)
-        m = build.method.substring(0, build.method.indexOf("("));
-    const param = {
-        from: client.ethWallet.address,
-        ...build.param,
-    };
-    const body = jsonrpcBody(m, [param]);
-    const response = await utils.httpCall.post(url, body, httpOpts);
-    utils.yellow(build.info.title);
-    utils.yellow(build.info.data);
-    transactionInfo = {
-        contract,
-        method: m,
-        build,
-    };
-    return response.data.result;
-}
-async function environment(env) {
-    if (env) {
-        config = loadConfig(env, config.versionApis);
-        await initConfigVars();
-        utils.yellow(`Environment ${env} loaded`);
-    }
-    else {
-        utils.yellow(`Current environment: ${config.env}`);
-    }
-    const { domain, contractAddresses, api, env: envConfig } = config;
-    utils.yellow({
-        domain,
-        contractAddresses,
-        urls: Object.keys(api).map((name) => api[name].url),
-        env: envConfig,
-        version: config.versionApis,
-    });
-}
-async function setVersionApis(version) {
-    if (version) {
-        config = loadConfig(config.env, version);
-        await initConfigVars();
-        utils.yellow(`Version ${config.versionApis} loaded`);
-    }
-    else {
-        utils.yellow(`Current version: ${config.versionApis}`);
-    }
-    const { domain, contractAddresses, api, env: envConfig } = config;
-    utils.yellow({
-        domain,
-        contractAddresses,
-        urls: Object.keys(api).map((name) => api[name].url),
-        env: envConfig,
-        version: config.versionApis,
-    });
-}
-async function setDomain(dom) {
-    if (dom) {
-        Object.keys(config.api).forEach((apiName) => {
-            config.api[apiName].url = config.api[apiName].url.replace(config.domain, dom);
-        });
-        config.domain = dom;
-        await setVar("domain", config.domain);
-    }
-    utils.yellow(`Current domain: ${config.domain}`);
-}
-function fileSystem(method, ...params) {
-    switch (method) {
-        case "readBinaryFile": {
-            const [filename] = params;
-            Joi.assert(filename, Joi.string());
-            return fs.readFileSync(filename);
-        }
-        case "writeBinaryFile": {
-            const filename = readValue(params[0]);
-            const data = readValue(params[1]);
-            Joi.assert(filename, Joi.string());
-            fs.writeFileSync(filename, data);
-            return 0;
-        }
-        default:
-            throw new Error(`Invalid method '${method}'`);
-    }
-}
-function readFile(filename) {
-    try {
-        // get the file from the working directory
-        return fs.readFileSync(filename, "utf-8");
-    }
-    catch {
-        // otherwise get the file from the internal scripts of the CLI tool
-        try {
-            return fs.readFileSync(new URL(`scripts/${filename}`, import.meta.url), "utf8");
-        }
-        catch {
-            throw new Error(`Can't open script ${filename}`);
-        }
-    }
-}
-async function run(filename, inputs = []) {
-    const filedata = readFile(filename);
-    const lines = filedata.split(/\r?\n/);
-    let response;
-    for (let i = 0; i < lines.length; i += 1) {
-        let line = lines[i].trim();
-        if (line.length > 0 && !line.startsWith("#")) {
-            inputs.forEach((input, j) => {
-                const param = typeof input === "string" ? input : JSON.stringify(input);
-                line = line.replace(new RegExp(`\\$${j + 1}`, "g"), param);
-            });
-            try {
-                response = await execCommand(line, true);
-            }
-            catch (error) {
-                utils.red(error.stack);
-                throw new Error(`Error in line ${i + 1}: ${error.message}`);
-            }
-        }
-        else {
-            console.log(line);
-        }
-    }
-    return response;
-}
-export async function execCommand(command, printCommand = false) {
-    if (printCommand)
-        console.log(`==> ${command}`);
-    const parts = parseLine(command);
-    let varName = "";
-    if (parts.length === 0)
-        return 0;
-    if (typeof parts[0] === "string" && parts[0].includes(":")) {
-        varName = parts[0].replace(":", "");
-        parts.shift();
-    }
-    const [part0, part1] = parts;
-    const parts2 = parts.slice(2);
-    const method = part0;
-    const word1 = part1;
-    Joi.assert(method, Joi.string());
-    // APIs linked to smart contracts
-    if (["timestamp", "did", "tir", "tsr", "tpr", "tnt"].includes(method)) {
-        Joi.assert(word1, Joi.string());
-        const response = await smartContractApi(method, word1, ...parts2);
-        if (varName)
-            await setVar(varName, response);
-        return response;
-    }
-    const schemaStrings = Joi.array().items(Joi.string());
-    const context = {
-        config,
-        httpOpts,
-        client,
-        rtVars,
-        transactionInfo,
-        token,
-    };
-    // Other APIs and configurations
-    switch (method) {
-        case "fs": {
-            Joi.assert(word1, Joi.string());
-            const response = fileSystem(word1, ...parts2);
-            console.log(response);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "set": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            let value = inputs[0];
-            if (inputs.length > 1) {
-                Joi.assert(inputs, schemaStrings);
-                value = inputs.join("");
-            }
-            await setVar(word1, value);
-            return value;
-        }
-        case "view": {
-            Joi.assert(word1, Joi.string());
-            return view([readValue(word1)], context);
-        }
-        case "using": {
-            Joi.assert(word1, Joi.string());
-            const user = await using(word1, ...parts2);
-            return user;
-        }
-        case "hardwarewallet":
-        case "hw": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => {
-                if (word1 === "setpin")
-                    return p;
-                return readValue(p);
-            });
-            const response = await hardwarewallet(word1, inputs, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "env": {
-            Joi.assert(word1, Joi.string().optional());
-            const input = readValue(word1);
-            await environment(input);
-            return 0;
-        }
-        case "version": {
-            Joi.assert(word1, Joi.string().optional());
-            const input = readValue(word1);
-            await setVersionApis(input);
-            return 0;
-        }
-        case "domain": {
-            Joi.assert(word1, Joi.string());
-            await setDomain(word1);
-            return 0;
-        }
-        case "get": {
-            Joi.assert(word1, Joi.string());
-            const input = readValue(word1);
-            const response = await utils.httpCall.get(input, context.httpOpts);
-            if (varName)
-                await setVar(varName, response.data);
-            return response.data;
-        }
-        case "authorisation": {
-            Joi.assert(word1, Joi.string());
-            Joi.assert(parts2, schemaStrings);
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await authorisationV4(word1, inputs, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "proxyledger": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await ledgerV4(word1, inputs, true, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "ledger": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await ledgerV4(word1, inputs, false, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "tnl": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await tnl(word1, inputs, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "conformance": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await conformanceV3(word1, inputs, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "compute": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await compute(word1, inputs, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "load": {
-            const filename = readValue(word1);
-            const data = readFile(filename);
-            let response;
-            try {
-                response = JSON.parse(data);
-            }
-            catch {
-                response = data;
-            }
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "export": {
-            let data = readValue(word1);
-            const filename = readValue(parts2[0]);
-            if (typeof data === "object") {
-                data = JSON.stringify(data, null, 2);
-            }
-            const absolutePath = path.isAbsolute(filename)
-                ? filename
-                : path.join(`${process.cwd()}`, filename);
-            fs.writeFileSync(filename, data);
-            utils.yellow(`file saved at ${absolutePath}`);
-            return undefined;
-        }
-        case "run": {
-            Joi.assert(word1, Joi.string());
-            const inputs = parts2.map((p) => readValue(p));
-            const response = await run(word1, inputs);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "exit": {
-            process.exit(0);
-            return 0;
-        }
-        default:
-            throw new Error(`Invalid method '${method}'`);
-    }
-}
-export async function main() {
-    await initConfigVars();
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const command = await utils.askQuestion("==> ");
-        try {
-            await execCommand(command);
-        }
-        catch (error) {
-            utils.red(error.stack);
         }
     }
 }