@cef-ebsi/cli 1.3.2 → 1.5.0

package/dist/commands/compute.js

@@ -1,271 +1,29 @@
-import { randomUUID, randomBytes, createHash, } from "node:crypto";
-import Multihash from "multihashes";
-import { ethers } from "ethers";
-import { base64url, calculateJwkThumbprint } from "jose";
 import { util } from "@cef-ebsi/ebsi-did-resolver";
-import Joi from "joi";
-import { decodeJWT } from "did-jwt";
 import { ValidationError, verifyCredentialJwt, } from "@cef-ebsi/verifiable-credential";
 import { verifyPresentationJwt, } from "@cef-ebsi/verifiable-presentation";
 import { EbsiWallet } from "@cef-ebsi/wallet-lib";
-import { formatEthersUnsignedTransaction, removePrefix0x, yellow, red, computeSchemaId, multibaseEncode, encodePublicKey, encodePrivateKey, } from "../utils/index.js";
-import { ledgerGetTransaction, ledgerGetTransactionReceipt, } from "./ledger-v4.js";
-export function getUserPin(did) {
-    return createHash("sha256")
-        .update(did)
-        .digest()
-        .slice(-4)
-        .map((byte) => byte % 10)
-        .reduce((acc, digit) => `${acc}${digit}`, "");
-}
-export async function computeVerifyVcJwt(inputs, context) {
-    const [vcJwt, options, expectedResult] = inputs;
-    const ebsiEnvConfig = {
-        hosts: [context.config.domain.replace(/^https?:\/\//, "")],
-        scheme: "ebsi",
-        network: {
-            name: context.config.env,
-            isOptional: false,
-        },
-        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 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 ebsiEnvConfig = {
-        hosts: [context.config.domain.replace(/^https?:\/\//, "")],
-        scheme: "ebsi",
-        network: {
-            name: context.config.env,
-            isOptional: false,
-        },
-        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 verifyPresentationJwt(vpJwt, audience, ebsiEnvConfig, options);
-    return "Verifiable Presentation is valid";
-}
-export function sha256(data) {
-    let hash = createHash("sha256");
-    if (data.startsWith("0x")) {
-        hash = hash.update(removePrefix0x(data), "hex");
-    }
-    else {
-        hash = hash.update(data, "utf8");
-    }
-    return hash.digest().toString("hex");
-}
-export function getProperties(input) {
-    return Object.keys(input)
-        .filter((key) => Number.isNaN(Number(key)))
-        .reduce((obj, key) => {
-        /* eslint-disable-next-line no-param-reassign */
-        obj[key] = input[key];
-        return obj;
-    }, {});
-}
-export function getApiByContractId(contractId, context) {
-    const apiName = Object.keys(context.config.api).find((a) => {
-        const api = context.config.api[a];
-        return (api.contract &&
-            contractId.toLowerCase() === api.contract.address.toLowerCase());
-    });
-    if (!apiName)
-        throw new Error(`cannot get API with address ${contractId}`);
-    return context.config.api[apiName];
-}
-export function decodeLog(log, context) {
-    const api = getApiByContractId(log.address, context);
-    const logDecoded = api.contract.interface.parseLog(log);
-    const { name, signature, topic, args: argsWithArray } = logDecoded;
-    const args = getProperties(argsWithArray);
-    return { name, signature, topic, args };
-}
-export async function decodeLogs(input, context) {
-    if (!input)
-        throw new Error("Invalid logs: no input provided");
-    let receipt;
-    let logs;
-    if (typeof input === "string") {
-        receipt = await ledgerGetTransactionReceipt([input], false, context);
-    }
-    if (input.receipt) {
-        receipt = input.receipt;
-    }
-    if (input.logs) {
-        receipt = input;
-    }
-    if (receipt) {
-        if (!Array.isArray(receipt.logs)) {
-            throw new Error("Invalid logs: The input must be a transaction hash, a transaction receipt, or an array of logs");
-        }
-        logs = receipt.logs;
-    }
-    else {
-        if (!Array.isArray(input)) {
-            throw new Error("Invalid logs: The input must be a transaction hash, a transaction receipt, or an array of logs");
-        }
-        logs = input;
-    }
-    return logs.map((log) => decodeLog(log, context));
-}
-export async function decodeTransaction(tx, context) {
-    let txData;
-    if (typeof tx === "string") {
-        txData = (await ledgerGetTransaction([tx], false, context));
-    }
-    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 { args, functionFragment } = api.contract.interface.parseTransaction({
-        data: (txData.data || txData.input),
-    });
-    return { name: functionFragment.name, args: getProperties(args) };
-}
+import { decodeJWT } from "did-jwt";
+import { ethers } from "ethers";
+import Joi from "joi";
+import { base64url, calculateJwkThumbprint } from "jose";
+import Multihash from "multihashes";
+import { createHash, randomBytes, randomUUID, } from "node:crypto";
+import { computeSchemaId, encodePrivateKey, encodePublicKey, formatEthersUnsignedTransaction, 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 "signTransaction": {
-            const unsignedTransaction = inputs[0];
-            const uTx = formatEthersUnsignedTransaction(JSON.parse(JSON.stringify(unsignedTransaction)));
-            const sgnTx = await client.ethWallet.signTransaction(uTx);
-            yellow(sgnTx);
-            return sgnTx;
-        }
-        case "createVpJwt": {
-            const inputVerifiableCredential = inputs[0];
-            const payloadVp = inputs[1];
-            const payloadJwt = inputs[2];
-            const alg = inputs[3] || "ES256K";
-            const verifiableCredential = typeof inputVerifiableCredential === "string"
-                ? [inputVerifiableCredential]
-                : inputVerifiableCredential;
-            // NOTE: We cannot use @cef-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);
-            const jti = `urn:did:${randomUUID()}`;
-            const payload = {
-                iat: now,
-                jti,
-                nbf: now - 60, // 1 minute in the past
-                exp: now + 120, // 2 minutes in the future
-                sub: client.did,
-                iss: client.did,
-                vp: {
-                    "@context": ["https://www.w3.org/2018/credentials/v1"],
-                    id: jti,
-                    type: ["VerifiablePresentation"],
-                    holder: client.did,
-                    verifiableCredential,
-                    ...payloadVp,
-                },
-                aud: "any",
-                nonce: randomUUID(),
-                ...payloadJwt,
-            };
-            const vp = await client.signJWT(payload, {}, alg);
-            yellow(vp);
-            return vp;
-        }
-        case "createVcJwt": {
-            const payloadVc = inputs[0];
-            const payloadJwt = inputs[1];
-            const alg = (inputs[2] || "ES256K");
-            Joi.assert(alg, Joi.string().valid("ES256K", "ES256", "RS256", "EdDSA").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 = {
-                iat,
-                jti,
-                nbf: iat,
-                exp,
-                sub,
-                iss: client.did,
-                vc: {
-                    "@context": ["https://www.w3.org/2018/credentials/v1"],
-                    id: jti,
-                    type: ["VerifiableCredential"],
-                    issuer: client.did,
-                    issuanceDate,
-                    issued: issuanceDate,
-                    validFrom: issuanceDate,
-                    expirationDate,
-                    ...payloadVc,
-                },
-                ...payloadJwt,
-            };
-            const vc = await client.signJWT(payload, {}, alg);
-            yellow(vc);
-            return vc;
-        }
-        case "signJwt": {
-            const [payload, alg, headers] = inputs;
-            const jwt = await client.signJWT(payload, headers, alg);
-            yellow(jwt);
-            return jwt;
-        }
-        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;
-        }
-        case "userPin": {
-            const [did] = inputs;
-            const userPin = getUserPin(did);
-            yellow(userPin);
-            return userPin;
-        }
-        case "schemaId": {
-            const [schema, base] = inputs;
-            const schemaId = await computeSchemaId(schema, base);
-            yellow(schemaId);
-            return schemaId;
+        case "address": {
+            const [hexOrJwk] = inputs;
+            const publicKeyHex = typeof hexOrJwk === "string"
+                ? hexOrJwk
+                : encodePublicKey({
+                    format: "hex",
+                    key: hexOrJwk,
+                });
+            const address = ethers.utils.computeAddress(publicKeyHex);
+            yellow(address);
+            return address;
         }
         case "checkStatusList2021CredentialSchema": {
             const [credential] = inputs;
@@ -279,24 +37,24 @@ export async function compute(method, inputs, context) {
                         .required())
                         .items(Joi.string().uri())
                         .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(),
                     credentialSubject: Joi.object({
+                        encodedList: Joi.string().required(),
                         id: Joi.string().uri().required(),
-                        type: Joi.string().valid("StatusList2021").required(),
                         statusPurpose: Joi.string()
                             .valid("revocation", "suspension")
                             .required(),
-                        encodedList: Joi.string().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));
@@ -346,58 +104,80 @@ export async function compute(method, inputs, context) {
             yellow(did);
             return did;
         }
-        case "sha256": {
-            const [data] = inputs;
-            if (typeof data === "object") {
-                return sha256(JSON.stringify(data));
-            }
-            return sha256(data);
-        }
-        case "decodeJWT": {
-            const jwt = inputs[0];
-            Joi.assert(jwt, Joi.string());
-            const decoded = decodeJWT(jwt);
-            yellow(decoded);
-            return decoded;
-        }
-        case "encodePublicKey": {
-            const [key, options] = inputs;
-            Joi.assert(options, Joi.object({
-                format: Joi.string().valid("jwk", "hex", "pem"),
-                alg: Joi.string()
-                    .valid("ES256K", "ES256", "RS256", "EdDSA")
-                    .optional(),
-            }));
-            const result = encodePublicKey({ key, ...options });
-            yellow(result);
-            return result;
-        }
-        case "encodePrivateKey": {
-            const [key, options] = inputs;
-            Joi.assert(options, Joi.object({
-                format: Joi.string().valid("jwk", "hex", "pem"),
-                alg: Joi.string()
-                    .valid("ES256K", "ES256", "RS256", "EdDSA")
-                    .optional(),
-                type: Joi.string().valid("pkcs1", "pkcs8", "sec1", "spki").optional(),
-            }));
-            const result = encodePrivateKey({ key, ...options });
-            yellow(result);
-            return result;
-        }
-        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 "createVcJwt": {
+            const payloadVc = inputs[0];
+            const payloadJwt = inputs[1];
+            const alg = (inputs[2] || "ES256K");
+            Joi.assert(alg, Joi.string().valid("ES256K", "ES256", "RS256", "EdDSA").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 = {
+                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,
+            };
+            const vc = await client.signJWT(payload, {}, alg);
+            yellow(vc);
+            return vc;
         }
-        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 "createVpJwt": {
+            const inputVerifiableCredential = inputs[0];
+            const payloadVp = inputs[1];
+            const payloadJwt = inputs[2];
+            const alg = inputs[3] || "ES256K";
+            const verifiableCredential = typeof inputVerifiableCredential === "string"
+                ? [inputVerifiableCredential]
+                : inputVerifiableCredential;
+            // NOTE: We cannot use @cef-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);
+            const jti = `urn:did:${randomUUID()}`;
+            const payload = {
+                aud: "any",
+                exp: now + 120, // 2 minutes in the future
+                iat: now,
+                iss: client.did,
+                jti,
+                nbf: now - 60, // 1 minute in the past
+                nonce: randomUUID(),
+                sub: client.did,
+                vp: {
+                    "@context": ["https://www.w3.org/2018/credentials/v1"],
+                    holder: client.did,
+                    id: jti,
+                    type: ["VerifiablePresentation"],
+                    verifiableCredential,
+                    ...payloadVp,
+                },
+                ...payloadJwt,
+            };
+            const vp = await client.signJWT(payload, {}, alg);
+            yellow(vp);
+            return vp;
         }
         case "decodeBase64": {
             const enc = inputs[0];
@@ -424,6 +204,28 @@ export async function compute(method, inputs, context) {
             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.utils.defaultAbiCoder.decode(types, data);
+            const result = {
+                data: decoded,
+                ...(fn && { functionSig: fn }),
+            };
+            yellow(result);
+            return result;
+        }
         case "decodeHex": {
             const enc = inputs[0];
             Joi.assert(enc, Joi.string());
@@ -431,26 +233,102 @@ export async function compute(method, inputs, context) {
             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 "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.utils.defaultAbiCoder.encode(types, data);
+            let result = encoded;
+            if (fn) {
+                // get the function hash
+                const fnHash = /^(?:0x)?[0-9a-fA-F]+$/.test(fn)
+                    ? fn
+                    : ethers.utils.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 "timestampId": {
-            const hash = inputs[0];
-            Joi.assert(hash, Joi.string());
-            const bufferSha256 = Buffer.from(sha256(hash), "hex");
-            const multihash = Multihash.encode(bufferSha256, "sha2-256", 32);
-            const timestampId = `u${base64url.encode(multihash)}`;
-            yellow(timestampId);
-            return timestampId;
+        case "randomID": {
+            return randomBytes(32).toString("hex");
         }
         case "recordId": {
             const [address, blockNumber, hashValue] = inputs;
@@ -461,37 +339,33 @@ export async function compute(method, inputs, context) {
             yellow(recordId);
             return recordId;
         }
-        case "randomID": {
-            return randomBytes(32).toString("hex");
+        case "schemaId": {
+            const [schema, base] = inputs;
+            const schemaId = await computeSchemaId(schema, base);
+            yellow(schemaId);
+            return schemaId;
         }
-        case "length": {
-            const [array] = inputs;
-            Joi.assert(array, Joi.array());
-            const len = array.length;
-            yellow(len);
-            return len;
+        case "sha256": {
+            const [data] = inputs;
+            if (typeof data === "object") {
+                return sha256(JSON.stringify(data));
+            }
+            return sha256(data);
         }
-        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 "signJwt": {
+            const [payload, alg, headers] = inputs;
+            const jwt = await client.signJWT(payload, headers, alg);
+            yellow(jwt);
+            return jwt;
         }
-        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 "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;
@@ -500,46 +374,212 @@ export async function compute(method, inputs, context) {
                 .update(did, "utf8")
                 .digest()
                 .slice(0, 6)
-                .readUInt32BE() % 131072).toString();
+                .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;
-            let publicKeyJwk;
-            if (typeof hexOrJwk === "string") {
-                publicKeyJwk = encodePublicKey({
-                    key: hexOrJwk,
-                    format: "jwk",
+            const publicKeyJwk = typeof hexOrJwk === "string"
+                ? encodePublicKey({
                     alg,
-                });
-            }
-            else {
-                publicKeyJwk = hexOrJwk;
-            }
+                    format: "jwk",
+                    key: hexOrJwk,
+                })
+                : hexOrJwk;
             const thumbprint = await calculateJwkThumbprint(publicKeyJwk, "sha256");
             yellow(thumbprint);
             return thumbprint;
         }
-        case "address": {
-            const [hexOrJwk] = inputs;
-            let publicKeyHex;
-            if (typeof hexOrJwk === "string") {
-                publicKeyHex = hexOrJwk;
+        case "timestampId": {
+            const hash = inputs[0];
+            Joi.assert(hash, Joi.string());
+            const bufferSha256 = Buffer.from(sha256(hash), "hex");
+            const multihash = Multihash.encode(bufferSha256, "sha2-256", 32);
+            const timestampId = `u${base64url.encode(multihash)}`;
+            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 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 verifyCredentialJwt(vcJwt, ebsiEnvConfig, options);
+        switch (expectedResult) {
+            case "expectRevoked": {
+                throw new Error("Credential is not revoked");
             }
-            else {
-                publicKeyHex = encodePublicKey({
-                    key: hexOrJwk,
-                    format: "hex",
-                });
+            default: {
+                return "Verifiable Credential is valid";
             }
-            const address = ethers.utils.computeAddress(publicKeyHex);
-            yellow(address);
-            return address;
         }
-        default:
-            throw new Error(`Invalid method '${method}'`);
     }
+    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 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 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);
+    const { args: argsWithArray, name, signature, topic } = logDecoded;
+    const args = getProperties(argsWithArray);
+    return { args, name, signature, topic };
+}
+export async function decodeLogs(input, context) {
+    if (!input)
+        throw new Error("Invalid logs: no input provided");
+    let receipt;
+    let logs;
+    if (typeof input === "string") {
+        receipt = await ledgerGetTransactionReceipt([input], false, context);
+    }
+    if (input.receipt) {
+        receipt = input.receipt;
+    }
+    if (input.logs) {
+        receipt = input;
+    }
+    if (receipt) {
+        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");
+        }
+        logs = receipt.logs;
+    }
+    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");
+        }
+        logs = input;
+    }
+    return 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.utils.parseTransaction(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 { args, functionFragment } = api.contract.interface.parseTransaction({
+        data: (txData.data || txData.input),
+    });
+    return {
+        dataDecoded: { args: getProperties(args), name: functionFragment.name },
+        tx: txData,
+    };
+}
+export function getApiByContractId(contractId, context) {
+    const apiName = Object.keys(context.config.api).find((a) => {
+        const api = context.config.api[a];
+        return (api.contract &&
+            contractId.toLowerCase() === api.contract.address.toLowerCase());
+    });
+    if (!apiName)
+        throw new Error(`cannot get API with address ${contractId}`);
+    return context.config.api[apiName];
+}
+export function getProperties(input) {
+    return Object.keys(input)
+        .filter((key) => Number.isNaN(Number(key)))
+        .reduce((obj, key) => {
+        obj[key] = input[key];
+        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");
 }
 export default compute;
 //# sourceMappingURL=compute.js.map