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

package/dist/commands/compute.js

@@ -1,680 +0,0 @@
-import { decodeJWT } from "@europeum-ebsi/did-jwt";
-import { util } from "@europeum-ebsi/ebsi-did-resolver";
-import { ValidationError } from "@europeum-ebsi/verifiable-credential";
-import * as vcdm11vc from "@europeum-ebsi/verifiable-credential/vcdm11.js";
-import * as vcdm20vc from "@europeum-ebsi/verifiable-credential/vcdm20.js";
-import * as vcdm11vp from "@europeum-ebsi/verifiable-presentation/vcdm11.js";
-import * as vcdm20vp from "@europeum-ebsi/verifiable-presentation/vcdm20.js";
-import { EbsiWallet } from "@europeum-ebsi/wallet-lib";
-import { ethers } from "ethers";
-import Joi from "joi";
-import { base64url, calculateJwkThumbprint } from "jose";
-import { sha256 as hasher } from "multiformats/hashes/sha2";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { computeSchemaId, encodePrivateKey, encodePublicKey, estimateVcdmVersion, formatEthersUnsignedTransaction, fromHexString, JoiHexadecimal, multibaseEncode, prefixWith0x, red, removePrefix0x, yellow, } from "../utils/index.js";
-import { ledgerGetTransaction, ledgerGetTransactionReceipt } from "./ledger.js";
-export async function compute(method, inputs, context) {
-    const { client } = context;
-    switch (method) {
-        case "address": {
-            const [hexOrJwk] = inputs;
-            const publicKeyHex = typeof hexOrJwk === "string"
-                ? hexOrJwk
-                : encodePublicKey({
-                    format: "hex",
-                    key: hexOrJwk,
-                });
-            const address = ethers.computeAddress(publicKeyHex);
-            yellow(address);
-            return address;
-        }
-        case "checkStatusList2021CredentialSchema": {
-            const [credential] = inputs;
-            try {
-                Joi.assert(credential, Joi.object({
-                    "@context": Joi.array()
-                        .ordered(Joi.string()
-                        .valid("https://www.w3.org/2018/credentials/v1")
-                        .required(), Joi.string()
-                        .valid("https://w3id.org/vc/status-list/2021/v1")
-                        .required())
-                        .items(Joi.string().uri())
-                        .required(),
-                    credentialSubject: Joi.object({
-                        encodedList: Joi.string().required(),
-                        id: Joi.string().uri().required(),
-                        statusPurpose: Joi.string()
-                            .valid("revocation", "suspension")
-                            .required(),
-                        type: Joi.string().valid("StatusList2021").required(),
-                    })
-                        .unknown(true)
-                        .required(),
-                    type: Joi.array()
-                        .ordered(
-                    // First item must be "VerifiableCredential"
-                    Joi.string().valid("VerifiableCredential").required())
-                        .items(
-                    // "StatusList2021Credential" must be present
-                    Joi.string().valid("StatusList2021Credential").required(), Joi.string())
-                        .required(),
-                })
-                    // Allow additional properties
-                    .unknown(true));
-                yellow("StatusList2021 Credential Schema correct");
-                return true;
-            }
-            catch (error) {
-                red(error);
-                throw error;
-            }
-        }
-        case "verifyVcJwt": {
-            try {
-                const result = await computeVerifyVcJwt(inputs, context);
-                yellow(result);
-                return result;
-            }
-            catch (error) {
-                if (error instanceof ValidationError) {
-                    red(error.toJSON());
-                }
-                else {
-                    red(error);
-                }
-                throw error;
-            }
-        }
-        case "verifyVpJwt": {
-            try {
-                const result = await computeVerifyVpJwt(inputs, context);
-                yellow(result);
-                return result;
-            }
-            catch (error) {
-                if (error instanceof ValidationError) {
-                    red(error.toJSON());
-                }
-                else {
-                    red(error);
-                }
-                throw error;
-            }
-        }
-        case "did2": {
-            const [jwk] = inputs;
-            const did = EbsiWallet.createDid("NATURAL_PERSON", jwk);
-            yellow(did);
-            return did;
-        }
-        case "createVcJwt": {
-            const payloadVc = inputs[0];
-            const payloadJwt = inputs[1];
-            const alg = (inputs[2] ?? "ES256K");
-            const vcdmVersionInput = (inputs[3] ?? "1.1");
-            Joi.assert(alg, Joi.string().valid("ES256K", "ES256", "RS256", "EdDSA").required());
-            let vcdmVersion;
-            if (vcdmVersionInput === 1.1)
-                vcdmVersion = "1.1";
-            else if (vcdmVersionInput === 2)
-                vcdmVersion = "2.0";
-            else
-                vcdmVersion = vcdmVersionInput;
-            Joi.assert(vcdmVersion, Joi.string().valid("1.1", "2.0").required());
-            const iat = Math.floor(Date.now() / 1000) - 10;
-            const exp = iat + 5 * 365 * 24 * 3600;
-            const issuanceDate = `${new Date(iat * 1000)
-                .toISOString()
-                .slice(0, -5)}Z`;
-            const expirationDate = `${new Date(exp * 1000)
-                .toISOString()
-                .slice(0, -5)}Z`;
-            const jti = payloadVc.id ?? `urn:uuid:${randomUUID()}`;
-            const sub = payloadVc.credentialSubject?.id;
-            const payload = vcdmVersion === "1.1"
-                ? {
-                    exp,
-                    iat,
-                    iss: client.did,
-                    jti,
-                    nbf: iat,
-                    sub,
-                    vc: {
-                        "@context": ["https://www.w3.org/2018/credentials/v1"],
-                        expirationDate,
-                        id: jti,
-                        issuanceDate,
-                        issued: issuanceDate,
-                        issuer: client.did,
-                        type: ["VerifiableCredential"],
-                        validFrom: issuanceDate,
-                        ...payloadVc,
-                    },
-                    ...payloadJwt,
-                }
-                : {
-                    "@context": ["https://www.w3.org/ns/credentials/v2"],
-                    exp,
-                    iat,
-                    id: jti,
-                    issuer: client.did,
-                    type: ["VerifiableCredential"],
-                    validFrom: issuanceDate,
-                    validUntil: expirationDate,
-                    ...payloadVc,
-                    ...payloadJwt,
-                };
-            const vc = await client.signJWT(payload, { typ: vcdmVersion === "1.1" ? "JWT" : "vc+jwt" }, alg);
-            yellow(vc);
-            return vc;
-        }
-        case "createVpJwt": {
-            const inputVerifiableCredential = inputs[0];
-            const payloadVp = inputs[1];
-            const payloadJwt = inputs[2];
-            const alg = inputs[3] || "ES256K";
-            const vcdmVersionInput = (inputs[4] ?? "1.1");
-            let vcdmVersion;
-            if (vcdmVersionInput === 1.1)
-                vcdmVersion = "1.1";
-            else if (vcdmVersionInput === 2)
-                vcdmVersion = "2.0";
-            else
-                vcdmVersion = vcdmVersionInput;
-            Joi.assert(vcdmVersion, Joi.string().valid("1.1", "2.0").required());
-            // NOTE: We cannot use @europeum-ebsi/verifiable-presentation library
-            // because it requires the private key and the CLI tool
-            // now supports Hardware Wallets, which do not expose private keys.
-            const now = Math.floor(Date.now() / 1000) - 10;
-            const jti = `urn:did:${randomUUID()}`;
-            const payload = vcdmVersion === "1.1"
-                ? {
-                    aud: "any",
-                    exp: now + 120, // 2 minutes in the future
-                    iat: now,
-                    iss: client.did,
-                    jti,
-                    nbf: now,
-                    nonce: randomUUID(),
-                    sub: client.did,
-                    vp: {
-                        "@context": ["https://www.w3.org/2018/credentials/v1"],
-                        holder: client.did,
-                        id: jti,
-                        type: ["VerifiablePresentation"],
-                        verifiableCredential: typeof inputVerifiableCredential === "string"
-                            ? [inputVerifiableCredential]
-                            : inputVerifiableCredential,
-                        ...payloadVp,
-                    },
-                    ...payloadJwt,
-                }
-                : {
-                    "@context": ["https://www.w3.org/ns/credentials/v2"],
-                    aud: "any",
-                    exp: now + 120, // 2 minutes in the future
-                    holder: client.did,
-                    iat: now,
-                    id: jti,
-                    nonce: randomUUID(),
-                    type: ["VerifiablePresentation"],
-                    verifiableCredential: (typeof inputVerifiableCredential ===
-                        "string"
-                        ? [inputVerifiableCredential]
-                        : inputVerifiableCredential).map((vc) => ({
-                        "@context": "https://www.w3.org/ns/credentials/v2",
-                        id: `data:application/vc+jwt,${vc}`,
-                        type: "EnvelopedVerifiableCredential",
-                    })),
-                    ...payloadVp,
-                    ...payloadJwt,
-                };
-            const vp = await client.signJWT(payload, { typ: vcdmVersion === "1.1" ? "JWT" : "vp+jwt" }, alg);
-            yellow(vp);
-            return vp;
-        }
-        case "decodeBase64": {
-            const enc = inputs[0];
-            const type = inputs[1] || "utf8";
-            Joi.assert(enc, Joi.string());
-            const buffer = Buffer.from(enc, "base64");
-            if (type === "buffer") {
-                console.log(buffer);
-                return buffer;
-            }
-            if (type === "json") {
-                const decoded = JSON.parse(buffer.toString("utf8"));
-                yellow(decoded);
-                return decoded;
-            }
-            const decoded = buffer.toString("utf8");
-            yellow(decoded);
-            return decoded;
-        }
-        case "decodeBase64url": {
-            const enc = inputs[0];
-            Joi.assert(enc, Joi.string());
-            const decoded = base64url.decode(enc);
-            yellow(decoded);
-            return decoded;
-        }
-        case "decodeContractData": {
-            const [types, dataInput, hasFn] = inputs;
-            Joi.assert(types, Joi.array().items(Joi.string()));
-            Joi.assert(dataInput, JoiHexadecimal);
-            Joi.assert(hasFn, Joi.string().valid("true", "false").optional());
-            let fn;
-            let data;
-            if (hasFn === "true") {
-                fn = `0x${removePrefix0x(dataInput).slice(0, 8)}`;
-                data = `0x${removePrefix0x(dataInput).slice(8)}`;
-            }
-            else {
-                data = dataInput;
-            }
-            const decoded = ethers.AbiCoder.defaultAbiCoder().decode(types, data);
-            const result = {
-                data: decoded,
-                ...(hasFn === "true" && { functionSig: fn }),
-            };
-            yellow(result);
-            return result;
-        }
-        case "decodeHex": {
-            const enc = inputs[0];
-            Joi.assert(enc, Joi.string());
-            const decoded = Buffer.from(removePrefix0x(enc), "hex").toString("utf8");
-            yellow(decoded);
-            return decoded;
-        }
-        case "decodeJWT": {
-            const jwt = inputs[0];
-            Joi.assert(jwt, Joi.string());
-            const decoded = decodeJWT(jwt);
-            yellow(decoded);
-            return decoded;
-        }
-        case "decodeLogs": {
-            const logs = inputs[0];
-            const logsDecoded = await decodeLogs(logs, context);
-            yellow(logsDecoded);
-            return logsDecoded;
-        }
-        case "decodeTransaction": {
-            const tx = inputs[0];
-            const txDecoded = await decodeTransaction(tx, context);
-            yellow(txDecoded);
-            return txDecoded;
-        }
-        case "encodeBase64": {
-            const dec = inputs[0];
-            Joi.assert(dec, Joi.string());
-            const encoded = Buffer.from(removePrefix0x(dec), "hex").toString("base64");
-            yellow(encoded);
-            return encoded;
-        }
-        case "encodeBase64url": {
-            const dec = inputs[0];
-            Joi.assert(dec, Joi.string());
-            const encoded = base64url.encode(Buffer.from(removePrefix0x(dec), "hex"));
-            yellow(encoded);
-            return encoded;
-        }
-        case "encodeContractData": {
-            const [types, data, fn] = inputs;
-            Joi.assert(data, Joi.array().items(Joi.string()));
-            Joi.assert(types, Joi.array().items(Joi.string()));
-            Joi.assert(fn, Joi.string().optional());
-            const encoded = ethers.AbiCoder.defaultAbiCoder().encode(types, data);
-            let result = encoded;
-            if (fn) {
-                // get the function hash
-                const fnHash = /^(?:0x)?[0-9a-fA-F]+$/.test(fn)
-                    ? fn
-                    : ethers.keccak256(Buffer.from(fn)).slice(0, 10);
-                // prefix the function hash with the encoded data
-                result = `${prefixWith0x(fnHash)}${encoded.slice(2)}`;
-            }
-            yellow(result);
-            return result;
-        }
-        case "encodePrivateKey": {
-            const [key, options] = inputs;
-            Joi.assert(options, Joi.object({
-                alg: Joi.string()
-                    .valid("ES256K", "ES256", "RS256", "EdDSA")
-                    .optional(),
-                format: Joi.string().valid("jwk", "hex", "pem"),
-                type: Joi.string().valid("pkcs1", "pkcs8", "sec1", "spki").optional(),
-            }));
-            const result = encodePrivateKey({ key, ...options });
-            yellow(result);
-            return result;
-        }
-        case "encodePublicKey": {
-            const [key, options] = inputs;
-            Joi.assert(options, Joi.object({
-                alg: Joi.string()
-                    .valid("ES256K", "ES256", "RS256", "EdDSA")
-                    .optional(),
-                format: Joi.string().valid("jwk", "hex", "pem"),
-            }));
-            const result = encodePublicKey({ key, ...options });
-            yellow(result);
-            return result;
-        }
-        case "epochtime": {
-            let result;
-            if (!inputs[0])
-                result = Math.round(Date.now() / 1000);
-            else if (typeof inputs[0] === "string")
-                result = Math.round(new Date(inputs[0]).getTime() / 1000);
-            else
-                result = new Date(inputs[0] * 1000).toISOString();
-            yellow(result);
-            return result;
-        }
-        case "length": {
-            const [array] = inputs;
-            Joi.assert(array, Joi.array());
-            const len = array.length;
-            yellow(len);
-            return len;
-        }
-        case "randomID": {
-            return randomBytes(32).toString("hex");
-        }
-        case "recordId": {
-            const [address, blockNumber, hashValue] = inputs;
-            Joi.assert(inputs, Joi.array().items(Joi.string()).length(3));
-            const abiEncoded = ethers.AbiCoder.defaultAbiCoder().encode(["address", "uint256", "bytes"], [address, blockNumber, hashValue]);
-            const bufferSha256 = Buffer.from(sha256(abiEncoded), "hex");
-            const recordId = multibaseEncode("base64url", bufferSha256);
-            yellow(recordId);
-            return recordId;
-        }
-        case "schemaId": {
-            const [schema, base] = inputs;
-            const schemaId = await computeSchemaId(schema, base);
-            yellow(schemaId);
-            return schemaId;
-        }
-        case "sha256": {
-            const [data] = inputs;
-            if (typeof data === "object") {
-                return sha256(JSON.stringify(data));
-            }
-            return sha256(data);
-        }
-        case "signJwt": {
-            const [payload, alg, headers] = inputs;
-            const jwt = await client.signJWT(payload, headers, alg);
-            yellow(jwt);
-            return jwt;
-        }
-        case "signTransaction": {
-            const unsignedTransaction = inputs[0];
-            const uTx = formatEthersUnsignedTransaction(
-            // eslint-disable-next-line unicorn/prefer-structured-clone
-            JSON.parse(JSON.stringify(unsignedTransaction)));
-            const sgnTx = await client.ethWallet.signTransaction(uTx);
-            yellow(sgnTx);
-            return sgnTx;
-        }
-        case "statusListIndex": {
-            const [did] = inputs;
-            Joi.assert(did, Joi.string());
-            const statusListIndex = (createHash("sha256")
-                .update(did, "utf8")
-                .digest()
-                .slice(0, 6)
-                .readUInt32BE() % 131_072).toString();
-            yellow(statusListIndex);
-            return statusListIndex;
-        }
-        case "subaccountDid": {
-            const [did] = inputs;
-            Joi.assert(did, Joi.string());
-            const subaccountMsiBytes = createHash("sha256")
-                .update(did, "utf8")
-                .digest()
-                .slice(0, 16);
-            const subaccount = util.createDid(subaccountMsiBytes);
-            yellow(subaccount);
-            return subaccount;
-        }
-        case "thumbprint": {
-            const [hexOrJwk, alg] = inputs;
-            const publicKeyJwk = typeof hexOrJwk === "string"
-                ? encodePublicKey({
-                    alg,
-                    format: "jwk",
-                    key: hexOrJwk,
-                })
-                : hexOrJwk;
-            const thumbprint = await calculateJwkThumbprint(publicKeyJwk, "sha256");
-            yellow(thumbprint);
-            return thumbprint;
-        }
-        case "timestampId": {
-            const hash = inputs[0];
-            Joi.assert(hash, Joi.string());
-            const multihash = await hasher.digest(fromHexString(hash));
-            const timestampId = `u${base64url.encode(multihash.bytes)}`;
-            yellow(timestampId);
-            return timestampId;
-        }
-        case "userPin": {
-            const [did] = inputs;
-            const userPin = getUserPin(did);
-            yellow(userPin);
-            return userPin;
-        }
-        case "wait": {
-            const [seconds] = inputs;
-            const milliseconds = Math.round(Number(seconds) * 1000);
-            console.log(`waiting ${milliseconds / 1000} seconds`);
-            await new Promise((r) => {
-                setTimeout(r, milliseconds);
-            });
-            return 0;
-        }
-        default: {
-            throw new Error(`Invalid method '${method}'`);
-        }
-    }
-}
-export async function computeVerifyVcJwt(inputs, context) {
-    const [vcJwt, options, expectedResult] = inputs;
-    const vcdmVersion = estimateVcdmVersion(vcJwt);
-    const ebsiEnvConfig = {
-        hosts: [context.config.domain.replace(/^https?:\/\//, "")],
-        network: {
-            isOptional: false,
-            name: context.config.env,
-        },
-        scheme: "ebsi",
-        services: {
-            "did-registry": context.config.api.did.version,
-            "trusted-issuers-registry": context.config.api.tir.version,
-            "trusted-policies-registry": context.config.api.tpr.version,
-            "trusted-schemas-registry": context.config.api.tsr.version,
-        },
-    };
-    try {
-        await (vcdmVersion === "1.1" ? vcdm11vc : vcdm20vc).verifyCredentialJwt(vcJwt, ebsiEnvConfig, options);
-        switch (expectedResult) {
-            case "expectRevoked": {
-                throw new Error("Credential is not revoked");
-            }
-            default: {
-                return "Verifiable Credential is valid";
-            }
-        }
-    }
-    catch (error) {
-        if (expectedResult === "expectRevoked") {
-            if (error.message === "Credential is not revoked")
-                throw error;
-            if (error.message.includes("revoked")) {
-                return "Verifiable Credential is revoked";
-            }
-        }
-        throw error;
-    }
-}
-export async function computeVerifyVpJwt(inputs, context) {
-    const [vpJwt, audience, options] = inputs;
-    const vcdmVersion = estimateVcdmVersion(vpJwt);
-    const ebsiEnvConfig = {
-        hosts: [context.config.domain.replace(/^https?:\/\//, "")],
-        network: {
-            isOptional: false,
-            name: context.config.env,
-        },
-        scheme: "ebsi",
-        services: {
-            "did-registry": context.config.api.did.version,
-            "trusted-issuers-registry": context.config.api.tir.version,
-            "trusted-policies-registry": context.config.api.tpr.version,
-            "trusted-schemas-registry": context.config.api.tsr.version,
-        },
-    };
-    await (vcdmVersion === "1.1" ? vcdm11vp : vcdm20vp).verifyPresentationJwt(vpJwt, audience, ebsiEnvConfig, options);
-    return "Verifiable Presentation is valid";
-}
-export function decodeLog(log, context) {
-    const api = getApiByContractId(log.address, context);
-    const logDecoded = api.contract.interface.parseLog(log);
-    if (!logDecoded)
-        throw new Error("Can't parse log");
-    const { args: argsWithArray, fragment, name, signature, topic } = logDecoded;
-    const args = getProperties(argsWithArray, fragment.inputs);
-    return { args, name, signature, topic };
-}
-export async function decodeLogs(input, context) {
-    if (!input)
-        throw new Error("Invalid logs: no input provided");
-    let receipt;
-    if (typeof input === "string") {
-        receipt = await ledgerGetTransactionReceipt([input], false, context);
-    }
-    else if (input.receipt) {
-        receipt = input.receipt;
-    }
-    else if (input.logs) {
-        receipt = input;
-    }
-    else {
-        if (!Array.isArray(input)) {
-            throw new TypeError("Invalid logs: The input must be a transaction hash, a transaction receipt, or an array of logs");
-        }
-        return input.map((log) => decodeLog(log, context));
-    }
-    if (!Array.isArray(receipt.logs)) {
-        throw new TypeError("Invalid logs: The input must be a transaction hash, a transaction receipt, or an array of logs");
-    }
-    return receipt.logs.map((log) => decodeLog(log, context));
-}
-export async function decodeTransaction(tx, context) {
-    let txData;
-    if (typeof tx === "string") {
-        txData =
-            tx.length <= 66
-                ? // it is a tx hash
-                    (await ledgerGetTransaction([tx], false, context))
-                : // it is a signed transaction
-                    ethers.Transaction.from(tx);
-    }
-    else {
-        txData = tx;
-    }
-    if (!txData["data"] && !txData["input"]) {
-        throw new Error("Invalid transaction: There is no input or data");
-    }
-    const api = getApiByContractId(txData["to"], context);
-    const parsedTx = api.contract.interface.parseTransaction({
-        data: (txData["data"] ?? txData["input"]),
-    });
-    if (!parsedTx)
-        throw new Error("Can't parse transaction");
-    const { args, fragment } = parsedTx;
-    return {
-        dataDecoded: {
-            args: getProperties(args, fragment.inputs),
-            name: fragment.name,
-        },
-        tx: txData,
-    };
-}
-export function getApiByContractId(contractId, context) {
-    const apiName = Object.keys(context.config.api)
-        .filter((a) => a !== "authorisation" && a !== "conformance" && a !== "ledger")
-        .find((a) => {
-        const api = context.config.api[a];
-        const contractAddress = context.config.contractAddresses[a];
-        return (api.contract &&
-            contractId.toLowerCase() === contractAddress.toLowerCase());
-    });
-    if (!apiName)
-        throw new Error(`cannot get API with address ${contractId}`);
-    return context.config.api[apiName];
-}
-export function getProperties(input, fragmentInputs) {
-    return fragmentInputs.reduce((obj, fragmentInput, index) => {
-        const value = Array.isArray(input)
-            ? input[index]
-            : input[fragmentInput.name];
-        obj[fragmentInput.name] = toPlainAbiValue(value, fragmentInput);
-        return obj;
-    }, {});
-}
-export function getUserPin(did) {
-    return createHash("sha256")
-        .update(did)
-        .digest()
-        .slice(-4)
-        .map((byte) => byte % 10)
-        .reduce((acc, digit) => `${acc}${digit}`, "");
-}
-export function sha256(data) {
-    let hash = createHash("sha256");
-    hash = data.startsWith("0x")
-        ? hash.update(removePrefix0x(data), "hex")
-        : hash.update(data, "utf8");
-    return hash.digest().toString("hex");
-}
-/**
- * Turn ethers ABI-decoded values (including struct/tuple {@link Result} arrays)
- * into plain JSON-serializable objects.
- */
-export function toPlainAbiValue(value, param) {
-    if (value == null) {
-        return value;
-    }
-    if (param.isTuple()) {
-        const components = param.components;
-        if (!Array.isArray(value)) {
-            throw new TypeError("tuple value must be array-like");
-        }
-        if (value.length !== components.length) {
-            throw new TypeError(`tuple length ${String(value.length)} !== ${String(components.length)}`);
-        }
-        return components.reduce((obj, component, index) => {
-            const key = component.name || `_${String(index)}`;
-            obj[key] = toPlainAbiValue(value[index], component);
-            return obj;
-        }, {});
-    }
-    if (param.isArray()) {
-        if (!Array.isArray(value)) {
-            throw new TypeError("array value must be an array");
-        }
-        return value.map((v) => toPlainAbiValue(v, param.arrayChildren));
-    }
-    if (typeof value === "bigint") {
-        return value.toString();
-    }
-    return value;
-}
-//# sourceMappingURL=compute.js.map