@europeum-ebsi/cli 0.0.0 → 1.0.0-rc.0

package/dist/app.js

@@ -1,659 +0,0 @@
-import { EbsiWallet } from "@europeum-ebsi/wallet-lib";
-import { ethers } from "ethers";
-import Joi from "joi";
-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 { authorisation, compute, conformance, hardwarewallet, ledger, tnl, view, waitToBeMined, } from "./commands/index.js";
-import { getRootAuthorisation } from "./commands/tir.js";
-import { loadConfig } from "./config.js";
-import { Client } from "./utils/Client.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;
-let token;
-let httpOpts = {
-    headers: {},
-};
-const rtVars = {}; // runtime variables
-const algSchema = Joi.string()
-    .valid("ES256K", "ES256", "RS256", "EdDSA")
-    .required();
-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", "tcr", "timestamp", "tir", "tnt", "tpr", "tsr"].includes(method)) {
-        Joi.assert(word1, Joi.string());
-        const inputs = parts2.map((p) => readValue(p)).filter(Boolean);
-        const response = await smartContractApi(method, word1, ...inputs);
-        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());
-            const inputs = parts2.map((p) => readValue(p)).filter(Boolean);
-            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))
-                .filter(Boolean);
-            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 (!filename)
-                throw new Error("Filename required");
-            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;
-        }
-        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);
-            })
-                .filter(Boolean);
-            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))
-                .filter(Boolean);
-            const response = await ledger(word1, inputs, false, context);
-            if (varName)
-                await setVar(varName, response);
-            return response;
-        }
-        case "load": {
-            const filename = readValue(word1);
-            if (!filename)
-                throw new Error("Filename required");
-            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))
-                .filter(Boolean);
-            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}'`);
-        }
-    }
-}
-export async function initConfigVars() {
-    await setVar("domain", config.domain, false);
-    await setVar("versionApis", config.versionApis, false);
-    await setVar("timestampUrl", config.api.timestamp.url, false);
-    await setVar("didUrl", config.api.did.url, false);
-    await setVar("tirUrl", config.api.tir.url, false);
-    await setVar("tsrUrl", config.api.tsr.url, false);
-    await setVar("tprUrl", config.api.tpr.url, false);
-    await setVar("tntUrl", config.api.tnt.url, false);
-    await setVar("ledgerUrl", config.api.ledger.url, false);
-    await setVar("authorisationUrl", config.api.authorisation.url, false);
-    await setVar("gasPrice", config.gasPrice, false);
-    await setVar("gasLimit", config.gasLimit, false);
-}
-export async function main() {
-    await initConfigVars();
-    while (true) {
-        const command = await utils.askQuestion("==> ");
-        try {
-            await execCommand(command);
-        }
-        catch (error) {
-            utils.red(error.stack);
-        }
-    }
-}
-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 { 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 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 (!fieldName || 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()) {
-                let param;
-                if (typeof input === "number") {
-                    param = `${input}`;
-                }
-                else if (typeof input === "string") {
-                    param = `"${input}"`;
-                }
-                else {
-                    param = JSON.stringify(input);
-                }
-                line = line.replaceAll(new RegExp(String.raw `\$${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}`, {
-                    cause: error,
-                });
-            }
-        }
-        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) {
-    if (!(contract in config.api)) {
-        throw new Error(`Unknown contract ${contract}`);
-    }
-    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 (contract === "tcr") {
-        throw new Error("TCR API does not have jsonrpc endpoint. Use `ledger tcr` instead.");
-    }
-    if (contract === "tir" && method === "getRootAuthorisation") {
-        return await getRootAuthorisation(inputs);
-    }
-    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,
-        };
-        transactionInfo.txId = response.data.result;
-        transactionInfo.receipt = await waitToBeMined(response.data.result, false, context);
-        return transactionInfo.receipt;
-    }
-    if (!method.startsWith("build-")) {
-        const inputsStr = inputs
-            .map((input) => {
-            let param;
-            if (typeof input === "number") {
-                param = `${input}`;
-            }
-            else if (typeof input === "string") {
-                param = `"${input}"`;
-            }
-            else {
-                param = JSON.stringify(input);
-            }
-            return param;
-        })
-            .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))
-        .filter(Boolean), 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) {
-    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();
-            utils.yellow(token);
-            return 0;
-        }
-        case "user": {
-            const existingUser = readValue(params[0]);
-            if (existingUser && typeof existingUser !== "string") {
-                // load the existing user
-                const hw = client.hardwareWallet;
-                client = new Client();
-                client.hardwareWallet = hw;
-                client.did = existingUser.did;
-                client.didVersion = existingUser.didVersion;
-                client.keys = existingUser.keys;
-                client.clientId = existingUser.clientId;
-                client.accreditationUrl = existingUser.accreditationUrl;
-                client.supportOfficeAccreditationUrl =
-                    existingUser.supportOfficeAccreditationUrl;
-                if (existingUser.accreditationUrl) {
-                    client.accreditationId = existingUser.accreditationUrl.slice(existingUser.accreditationUrl.lastIndexOf("/") + 1);
-                }
-                client.proxyId = existingUser.proxyId;
-                client.issuerState = existingUser.issuerState;
-                if (existingUser.keys?.ES256K?.privateKeyHex) {
-                    client.ethWallet = new ethers.Wallet(existingUser.keys.ES256K.privateKeyHex);
-                }
-                await setVar("user", client.toJSON(), false);
-                await execCommand("view user", false);
-                return client;
-            }
-            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 0;
-            }
-            const alg = readValue(params[0]) ?? "ES256K";
-            const didMethod = readValue(params[1]) ?? "did1";
-            const privateKey = readValue(params[2]);
-            client.did = readValue(params[3]) ?? client.did;
-            let verificationMethodId = readValue(params[4]);
-            Joi.assert(alg, algSchema);
-            if (client.keys[alg] && !privateKey) {
-                throw new Error([
-                    `Private key can not be generated randomly for alg '${alg}' `,
-                    "because it is already defined. If you want to update it ",
-                    "set a specific private key. If you want to create a new ",
-                    "random user remove the existing one first with the command ",
-                    "'using user null'.",
-                ].join(""));
-            }
-            const usingHardwareWallet = privateKey === "hardwarewallet" || privateKey === "hw";
-            if (usingHardwareWallet && alg !== "ES256") {
-                throw new Error("Hardware wallet must use alg ES256. The CLI does not support other algs");
-            }
-            if (alg === "ES256K") {
-                if (!privateKey) {
-                    client.ethWallet = ethers.Wallet.createRandom();
-                }
-                else if (typeof privateKey === "string") {
-                    client.ethWallet = new ethers.Wallet(prefixWith0x(privateKey));
-                }
-                else {
-                    client.ethWallet = new ethers.Wallet(utils.encodePrivateKey({
-                        format: "hex",
-                        key: privateKey,
-                    }));
-                }
-                const privateKeyJwk = utils.encodePrivateKey({
-                    alg,
-                    format: "jwk",
-                    key: client.ethWallet.privateKey,
-                });
-                client.setJwk(alg, privateKeyJwk);
-            }
-            else if (alg === "ES256" && usingHardwareWallet) {
-                client.hardwareWallet ??= new HardwareWallet(config.openSClib);
-                const publicKeyJwk = client.hardwareWallet.getPublicKey();
-                const publicKeyPem = utils.encodePublicKey({
-                    alg,
-                    format: "pem",
-                    key: publicKeyJwk,
-                });
-                client.keys.ES256 = {
-                    id: "",
-                    isHardwareWallet: true,
-                    kid: "",
-                    privateKeyJwk: undefined,
-                    publicKeyJwk,
-                    publicKeyPem,
-                };
-            }
-            else if (alg === "ES256" && typeof privateKey === "string") {
-                const privateKeyJwk = utils.encodePrivateKey({
-                    alg,
-                    format: "jwk",
-                    key: privateKey,
-                });
-                client.setJwk(alg, privateKeyJwk);
-            }
-            else {
-                const privateKeyJwk = privateKey;
-                if (privateKeyJwk) {
-                    client.setJwk(alg, privateKeyJwk);
-                }
-                else {
-                    await client.createRandom(alg);
-                }
-            }
-            switch (didMethod) {
-                case "did1": {
-                    client.didVersion = 1;
-                    client.did ??= EbsiWallet.createDid();
-                    verificationMethodId ??= await calculateJwkThumbprint(client.keys[alg].publicKeyJwk, "sha256");
-                    break;
-                }
-                case "did2": {
-                    client.didVersion = 2;
-                    client.did = EbsiWallet.createDid("NATURAL_PERSON", client.keys[alg].publicKeyJwk);
-                    verificationMethodId ??= client.did.slice(8);
-                    break;
-                }
-                default: {
-                    throw new Error("did method must be 'did1' or 'did2'");
-                }
-            }
-            client.keys[alg].id = verificationMethodId;
-            client.keys[alg].kid = `${client.did}#${verificationMethodId}`;
-            await setVar("user", client.toJSON(), false);
-            await execCommand("view user", false);
-            return client;
-        }
-        default: {
-            throw new Error(`Invalid subject '${method}'`);
-        }
-    }
-}
-//# sourceMappingURL=app.js.map