@europeum-ebsi/cli 0.0.0

package/dist/commands/compute.js

@@ -0,0 +1,680 @@
+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