@getcofund/cli 0.0.0-stage → 0.1.0

package/dist/commands/invite.js

@@ -0,0 +1,153 @@
+import { randomUUID } from "node:crypto";
+import { addUserCall, cofundClientId, INVITE_USER_TYPES, inviteExpiresAt, readRequiredAdminInviteSignatures, readUser, sameAddress, typedData, } from "@getcofund/protocol/evm";
+import { evmWallet } from "@getcofund/protocol/keys";
+import { requireAdmin, seatText } from "../chain.js";
+import { approved, evmChain, keystore, line, send, sender, } from "../context.js";
+import { keystorePath, pickCompany, pinCompany, readKeystore, requirePinned, } from "../keystore.js";
+import { loadSignatures, signMessage, writeSignatureFile, } from "../signature-file.js";
+import { USAGE } from "../usage.js";
+import { cofundLine, expiryText, signedByLines, userText } from "./lines.js";
+/**
+ * `invite`: an admin signs a seat. `invite cosign`: another admin co-signs an
+ * admin seat. `join`: the invitee signs the same message and sends `addUser`
+ * with every signature, which seats them.
+ */
+/** What an invite seats, as every step of it shows. */
+async function seatLines(evm, message) {
+    return [
+        cofundLine(message.company),
+        line("seat", `${message.userId}, ${message.userIsAdmin ? "admin" : "member"}, "${message.userPosition}"`),
+        line("inviter", await userText(evm, message.company, message.callerId)),
+        line("valid", expiryText(message.expiresAt)),
+    ];
+}
+/** An admin seat's signature rule, said. */
+async function adminRuleLine(evm, message) {
+    if (!message.userIsAdmin) {
+        return [];
+    }
+    const required = await readRequiredAdminInviteSignatures(evm.reader, evm.deployment, cofundClientId(message.company));
+    return [
+        line("needs", `${required} admin signature${required === 1 ? "" : "s"}, the inviter's included; other admins add theirs with \`invite cosign\``),
+    ];
+}
+export async function invite(io, flags) {
+    const userId = flags["user-id"];
+    const { position, out } = flags;
+    if (!(userId && position && out)) {
+        io.err(USAGE);
+        return 1;
+    }
+    const keys = keystore(io, flags);
+    const company = pickCompany(keys, flags.company);
+    const evm = await evmChain(io, flags);
+    const admin = evmWallet(keys);
+    const seat = await requireAdmin(evm, cofundClientId(company), admin.address);
+    const message = {
+        company,
+        callerId: seat.userId,
+        userId,
+        userIsAdmin: Boolean(flags.admin),
+        userPosition: position,
+        expiresAt: inviteExpiresAt(),
+        authId: randomUUID(),
+    };
+    for (const text of [
+        ...(await seatLines(evm, message)),
+        ...(await adminRuleLine(evm, message)),
+    ]) {
+        io.out(text);
+    }
+    if (!(await approved(io, flags, {
+        question: "Sign this invite?",
+        action: "sign it",
+    }))) {
+        return 1;
+    }
+    writeSignatureFile(out, await signMessage(admin, evm.deployment, { type: "InviteUser", message }));
+    io.out(line("wrote", `${out}: the invitee joins with it`));
+    return 0;
+}
+export async function inviteCosign(io, flags, files) {
+    const { out } = flags;
+    if (files.length === 0 || !out) {
+        io.err(USAGE);
+        return 1;
+    }
+    const evm = await evmChain(io, flags);
+    const signed = await loadSignatures(files, evm.deployment, ["InviteUser"]);
+    const message = signed[0].message;
+    const keys = keystore(io, flags);
+    requirePinned(keys, message.company, flags.company);
+    if (!message.userIsAdmin) {
+        throw new Error("A member's seat takes the inviter's signature alone: there is nothing to co-sign");
+    }
+    const admin = evmWallet(keys);
+    const seat = await requireAdmin(evm, cofundClientId(message.company), admin.address);
+    if (seat.userId === message.callerId) {
+        throw new Error("You are the inviter: a co-signature is another admin's");
+    }
+    for (const text of [
+        ...(await seatLines(evm, message)),
+        ...(await signedByLines(evm, message.company, signed)),
+        line("you", seatText(seat)),
+        ...(await adminRuleLine(evm, message)),
+    ]) {
+        io.out(text);
+    }
+    if (!(await approved(io, flags, {
+        question: "Co-sign this admin seat?",
+        action: "co-sign it",
+    }))) {
+        return 1;
+    }
+    writeSignatureFile(out, await signMessage(admin, evm.deployment, { type: "InviteUser", message }));
+    io.out(line("wrote", `${out}: the invitee joins with it and the others`));
+    return 0;
+}
+export async function join(io, flags, files) {
+    if (files.length === 0) {
+        io.err(USAGE);
+        return 1;
+    }
+    const evm = await evmChain(io, flags);
+    const signed = await loadSignatures(files, evm.deployment, ["InviteUser"]);
+    const message = signed[0].message;
+    if (flags.company !== undefined && flags.company !== message.company) {
+        throw new Error(`The invite is to company "${message.company}", not "${flags.company}"`);
+    }
+    const path = keystorePath(io.env, flags.keystore);
+    const invitee = evmWallet(readKeystore(path));
+    const via = sender(io, flags, evm);
+    const inviter = await readUser(evm.reader, evm.deployment, cofundClientId(message.company), message.callerId);
+    const inviting = signed.find(({ signer }) => inviter && sameAddress(signer, inviter.address));
+    if (!inviting) {
+        throw new Error(`None of the files is the inviting admin's (${message.callerId}${inviter ? ` at ${inviter.address}` : ", who holds no seat"})`);
+    }
+    for (const text of [
+        ...(await seatLines(evm, message)),
+        ...(await signedByLines(evm, message.company, signed)),
+        line("you", `${invitee.address} takes the seat`),
+    ]) {
+        io.out(text);
+    }
+    const call = await addUserCall(evm, {
+        message,
+        adminSignature: inviting.signature,
+        coSignatures: signed
+            .filter((each) => each !== inviting)
+            .map(({ signature }) => signature),
+        invitee: invitee.address,
+        inviteeSignature: await invitee.signTypedData(typedData(evm.deployment.eip712Domain, INVITE_USER_TYPES, message)),
+    });
+    io.out(line("call", `addUser on the users helper ${call.to}`));
+    const sent = await send(io, flags, { evm, via, call }, {
+        question: `Join "${message.company}" and pin its company?`,
+        action: "join",
+    });
+    if (sent === 0) {
+        pinCompany(path, message.company);
+        io.out(line("pinned", `company "${message.company}" in ${path}`));
+    }
+    return sent;
+}

package/dist/commands/keys.js

@@ -0,0 +1,36 @@
+import { existsSync } from "node:fs";
+import { generateKeystore } from "@getcofund/protocol/keys";
+import { keystore, line } from "../context.js";
+import { keystorePath, pinnedCompanies, writeKeystore } from "../keystore.js";
+/** `keys init`: an EVM key and a BIP-86 Bitcoin account, generated here and kept in the keystore. */
+export function keysInit(io, flags) {
+    const path = keystorePath(io.env, flags.keystore);
+    if (existsSync(path) && !flags.force) {
+        io.err(`${path} already exists; pass --force to replace it`);
+        return 1;
+    }
+    const network = io.env.COFUND_BTC_NETWORK ?? "mainnet";
+    if (!["mainnet", "testnet", "regtest"].includes(network)) {
+        io.err("COFUND_BTC_NETWORK is mainnet, testnet or regtest");
+        return 1;
+    }
+    // Regtest keys are testnet's: tpubs.
+    const keys = generateKeystore(network === "mainnet" ? "mainnet" : "testnet");
+    writeKeystore(path, keys);
+    io.out(line("keystore", path));
+    io.out(line("evm", keys.evm.address));
+    io.out(line("btc xpub", `${keys.btc.accountXpub} (${keys.btc.network})`));
+    return 0;
+}
+/** `keys show`: the keystore's EVM address, its Bitcoin account xpub, and the cofunds it pins. */
+export function keysShow(io, flags) {
+    const keys = keystore(io, flags);
+    io.out(line("keystore", keystorePath(io.env, flags.keystore)));
+    io.out(line("evm", keys.evm.address));
+    io.out(line("btc xpub", `${keys.btc.accountXpub} (${keys.btc.network})`));
+    const companies = pinnedCompanies(keys);
+    io.out(line("cofunds", companies.length === 0
+        ? "none pinned"
+        : companies.map((company) => `"${company}"`).join(", ")));
+    return 0;
+}

package/dist/commands/lines.js

@@ -0,0 +1,29 @@
+import { cofundClientId, readUser } from "@getcofund/protocol/evm";
+import { seatOf, seatText } from "../chain.js";
+import { line } from "../context.js";
+/** Preview lines several commands print. */
+export const cofundLine = (company) => line("cofund", `"${company}" (client id ${cofundClientId(company)})`);
+/** An `expiresAt` (unix seconds) as a preview says it. */
+export function expiryText(expiresAt) {
+    return `until ${new Date(Number(expiresAt) * 1000).toISOString()}`;
+}
+/** Who `address` is in the cofund: their seat, or that they hold none. */
+export async function whoText(evm, company, address) {
+    const seat = await seatOf(evm, cofundClientId(company), address);
+    return seat ? seatText(seat) : `${address} (no seat in this cofund)`;
+}
+/** A user id as the preview names it: their seat, or that there is none. */
+export async function userText(evm, company, userId) {
+    const user = await readUser(evm.reader, evm.deployment, cofundClientId(company), userId);
+    return user
+        ? seatText({ userId, user })
+        : `${userId} (no seat in this cofund)`;
+}
+/** Each signature's signer, by their seat. */
+export async function signedByLines(evm, company, signed) {
+    const lines = [];
+    for (const { signer } of signed) {
+        lines.push(line("signed by", await whoText(evm, company, signer)));
+    }
+    return lines;
+}

package/dist/commands/members.js

@@ -0,0 +1,145 @@
+import { randomUUID } from "node:crypto";
+import { cofundClientId, readUser, removeUserCall, rotateUserCall, sameAddress, } from "@getcofund/protocol/evm";
+import { evmWallet } from "@getcofund/protocol/keys";
+import { getAddress } from "viem";
+import { seatOf } from "../chain.js";
+import { line } from "../context.js";
+import { pickCompany } from "../keystore.js";
+import { USAGE } from "../usage.js";
+import { userText } from "./lines.js";
+import { signOrSend } from "./sign-or-send.js";
+/** `members remove`, `members rotate`: signed by admins (and keys), sent with the signatures given. */
+/** Whether `me` is an active admin who has not signed among `signed`. */
+async function adminRole(evm, company, me, signed) {
+    if (signed.some(({ signer }) => sameAddress(signer, me))) {
+        return { not: "the files hold your signature already" };
+    }
+    const seat = await seatOf(evm, cofundClientId(company), me);
+    return seat?.user.active && seat.user.isAdmin
+        ? { as: `admin ${seat.userId}` }
+        : { not: `${me} is no active admin of this cofund` };
+}
+export function membersRemove(io, flags, userId, files) {
+    if (!userId) {
+        io.err(USAGE);
+        return 1;
+    }
+    return signOrSend(io, flags, {
+        type: "RemoveUser",
+        files,
+        fresh: async (keys) => ({
+            company: pickCompany(keys, flags.company),
+            removedUserId: userId,
+            authId: randomUUID(),
+        }),
+        matches: (message) => {
+            if (message.removedUserId !== userId) {
+                throw new Error(`The files remove ${message.removedUserId}, not ${userId}`);
+            }
+        },
+        role: (evm, message, me, signed) => adminRole(evm, message.company, me, signed),
+        lines: async (evm, message) => [
+            line("remove", await userText(evm, message.company, message.removedUserId)),
+        ],
+        build: (evm, message, signed) => removeUserCall(evm, {
+            message,
+            signatures: signed.map(({ signature }) => signature),
+        }),
+        entry: "removeUser on the users helper",
+        question: `Remove ${userId}?`,
+    });
+}
+/**
+ * The seat a rotation moves, and who holds it now; null when there is none
+ * (the builder refuses it).
+ */
+async function rotated(evm, message) {
+    return await readUser(evm.reader, evm.deployment, cofundClientId(message.company), message.userId);
+}
+/**
+ * `members rotate`: a seat moved to a new key. The new key always signs,
+ * with the current key or (for a lost one) admins: each signs with `--out`,
+ * and the new key sends last with the others' files.
+ */
+export function membersRotate(io, flags, files) {
+    const userIdFlag = flags["user-id"];
+    const newAddressFlag = flags["new-address"];
+    return signOrSend(io, flags, {
+        type: "RotateUser",
+        files,
+        fresh: async (keys, evm) => {
+            if (!newAddressFlag) {
+                throw new Error("A new rotation names the key it moves to: pass --new-address");
+            }
+            const company = pickCompany(keys, flags.company);
+            let userId = userIdFlag;
+            if (!userId) {
+                const seat = await seatOf(evm, cofundClientId(company), evmWallet(keys).address);
+                if (!seat) {
+                    throw new Error("This key holds no seat to rotate: pass --user-id to rotate another's as an admin");
+                }
+                userId = seat.userId;
+            }
+            return {
+                company,
+                userId,
+                newAddress: getAddress(newAddressFlag),
+                authId: randomUUID(),
+            };
+        },
+        matches: (message) => {
+            if (userIdFlag !== undefined && message.userId !== userIdFlag) {
+                throw new Error(`The files rotate ${message.userId}, not ${userIdFlag}`);
+            }
+            if (newAddressFlag !== undefined &&
+                !sameAddress(message.newAddress, newAddressFlag)) {
+                throw new Error(`The files rotate to ${message.newAddress}, not ${newAddressFlag}`);
+            }
+        },
+        role: async (evm, message, me, signed) => {
+            if (signed.some(({ signer }) => sameAddress(signer, me))) {
+                return { not: "the files hold your signature already" };
+            }
+            if (sameAddress(me, message.newAddress)) {
+                return { as: "new key" };
+            }
+            const user = await rotated(evm, message);
+            const byAdmins = signed.some(({ signer }) => !(sameAddress(signer, message.newAddress) ||
+                (user && sameAddress(signer, user.address))));
+            if (user && sameAddress(me, user.address)) {
+                return byAdmins
+                    ? { not: "admins authorize this rotation, not the current key" }
+                    : { as: "current key" };
+            }
+            if (user &&
+                signed.some(({ signer }) => sameAddress(signer, user.address))) {
+                return { not: "the current key authorizes this rotation, not admins" };
+            }
+            return await adminRole(evm, message.company, me, signed);
+        },
+        lines: async (evm, message) => [
+            line("rotate", await userText(evm, message.company, message.userId)),
+            line("to", message.newAddress),
+        ],
+        build: async (evm, message, signed) => {
+            const user = await rotated(evm, message);
+            const newKey = signed.find(({ signer }) => sameAddress(signer, message.newAddress));
+            if (!newKey) {
+                throw new Error(`The new key ${message.newAddress} has not signed: it sends last, with the others' files`);
+            }
+            const current = signed.find(({ signer }) => user && sameAddress(signer, user.address));
+            // Both authorizations given at once are refused by the builder, as by the helper.
+            return rotateUserCall(evm, {
+                message,
+                newKeySignature: newKey.signature,
+                currentKeySignature: current?.signature,
+                adminSignatures: signed
+                    .filter((each) => each !== newKey && each !== current)
+                    .map(({ signature }) => signature),
+            });
+        },
+        entry: "rotateUser on the users helper",
+        question: "Rotate this seat to the new key?",
+        pinOnSend: true,
+    });
+}

package/dist/commands/onboarding.js

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+import { cofundClientId, completeOnboardingCall, } from "@getcofund/protocol/evm";
+import { requireAdmin } from "../chain.js";
+import { line } from "../context.js";
+import { pickCompany } from "../keystore.js";
+import { signOrSend } from "./sign-or-send.js";
+/**
+ * `onboarding complete [<file>]`: one active admin's `CompleteOnboarding`,
+ * this key's unless a file gives one, sent. It closes the founding phase for
+ * good: after it, seating an admin and activating a policy take the admins'
+ * consensus.
+ */
+export function onboardingComplete(io, flags, files) {
+    return signOrSend(io, flags, {
+        type: "CompleteOnboarding",
+        files,
+        fresh: async (keys) => ({
+            company: pickCompany(keys, flags.company),
+            authId: randomUUID(),
+        }),
+        matches: () => {
+            if (files.length > 1) {
+                throw new Error("It takes one admin's signature: one file");
+            }
+        },
+        role: async (evm, message, me, signed) => {
+            if (signed.length > 0) {
+                return { not: "it takes one admin's signature, and the file has it" };
+            }
+            const seat = await requireAdmin(evm, cofundClientId(message.company), me);
+            return { as: `admin ${seat.userId}` };
+        },
+        lines: async () => [
+            line("closes", "the onboarding phase, for good: admin seats and policies then take the admins' consensus"),
+        ],
+        build: (evm, message, [first]) => completeOnboardingCall(evm, { message, signature: first.signature }),
+        entry: "completeOnboarding on the users helper",
+        question: "Complete onboarding?",
+    });
+}

package/dist/commands/policies.js

@@ -0,0 +1,193 @@
+import { randomUUID } from "node:crypto";
+import { activateTransactionPolicyCall, activateTransferPolicyCall, cofundClientId, deactivatePolicyCall, readPolicy, readRequiredPolicyActivationSignatures, sameAddress, WRAPPER_ENTRYPOINT, } from "@getcofund/protocol/evm";
+import { evmWallet } from "@getcofund/protocol/keys";
+import { getAddress } from "viem";
+import { baseUnits, requireAdmin, seatText, tokenInfo } from "../chain.js";
+import { approved, evmChain, keystore, line, send, sender, } from "../context.js";
+import { pickCompany, requirePinned } from "../keystore.js";
+import { loadSignatures, signMessage, writeSignatureFile, } from "../signature-file.js";
+import { USAGE } from "../usage.js";
+import { cofundLine, signedByLines, userText } from "./lines.js";
+import { boundsLines } from "./reads.js";
+import { signOrSend } from "./sign-or-send.js";
+const ACTIVATIONS = [
+    "TransferPolicyActivation",
+    "TransactionPolicyActivation",
+];
+const isTransaction = (message) => "wrapper" in message;
+/** The policy an activation activates, as every step of it shows. */
+async function activationLines(evm, message) {
+    const signers = [];
+    for (const id of message.signerIds) {
+        signers.push(await userText(evm, message.company, id));
+    }
+    const required = await readRequiredPolicyActivationSignatures(evm.reader, evm.deployment, cofundClientId(message.company), BigInt(message.threshold));
+    const bounds = await boundsLines(evm, isTransaction(message)
+        ? { wrapper: getAddress(message.wrapper), func: message.func }
+        : {
+            token: getAddress(message.token),
+            maxAmount: BigInt(message.maxAmount),
+            recipients: message.recipients.map((r) => getAddress(r)),
+        });
+    return [
+        cofundLine(message.company),
+        line("policy", `${message.policyId}: "${message.title}" (${message.policyType})`),
+        line("signers", `${signers.join(", ")}; ${message.threshold} of ${message.signerIds.length} must sign`),
+        ...bounds,
+        line("activate", `takes ${required} admin signature${required === 1 ? "" : "s"}`),
+    ];
+}
+const POSITIVE = /^[1-9]\d*$/;
+const list = (text) => text
+    .split(",")
+    .map((each) => each.trim())
+    .filter(Boolean);
+/** A new activation from the flags: a transfer policy (token and cap), or a call policy (wrapper). */
+async function activationFrom(flags, company, evm) {
+    const { name, signers, threshold, token, wrapper } = flags;
+    const maxAmount = flags["max-amount"];
+    const transfer = Boolean(token && maxAmount);
+    if (!(name && signers && threshold && POSITIVE.test(threshold)) ||
+        transfer === Boolean(wrapper) ||
+        (flags.recipients && wrapper)) {
+        return null;
+    }
+    const common = {
+        company,
+        policyId: randomUUID(),
+        title: name,
+        policyType: flags.type ?? (wrapper ? "Treasury_Management" : "Operational_Expense"),
+        signerIds: list(signers),
+        threshold,
+    };
+    if (wrapper) {
+        return {
+            ...common,
+            wrapper: getAddress(wrapper),
+            func: WRAPPER_ENTRYPOINT,
+            authId: randomUUID(),
+        };
+    }
+    const address = getAddress(token);
+    return {
+        ...common,
+        token: address,
+        maxAmount: baseUnits(maxAmount, await tokenInfo(evm, address), "--max-amount").toString(),
+        recipients: list(flags.recipients ?? "").map((r) => getAddress(r)),
+        authId: randomUUID(),
+    };
+}
+export async function policiesSign(io, flags, files) {
+    const { out } = flags;
+    if (!out) {
+        io.err(USAGE);
+        return 1;
+    }
+    const keys = keystore(io, flags);
+    const evm = await evmChain(io, flags);
+    let message;
+    let signed = [];
+    if (files.length > 0) {
+        signed = await loadSignatures(files, evm.deployment, ACTIVATIONS);
+        message = signed[0].message;
+        requirePinned(keys, message.company, flags.company);
+    }
+    else {
+        message = await activationFrom(flags, pickCompany(keys, flags.company), evm);
+        if (!message) {
+            io.err(USAGE);
+            return 1;
+        }
+    }
+    const admin = evmWallet(keys);
+    const seat = await requireAdmin(evm, cofundClientId(message.company), admin.address);
+    if (signed.some(({ signer }) => sameAddress(signer, admin.address))) {
+        throw new Error("The files hold your signature already");
+    }
+    for (const text of [
+        ...(await activationLines(evm, message)),
+        ...(await signedByLines(evm, message.company, signed)),
+        line("you", seatText(seat)),
+    ]) {
+        io.out(text);
+    }
+    if (!(await approved(io, flags, {
+        question: "Sign this policy's activation?",
+        action: "sign it",
+    }))) {
+        return 1;
+    }
+    const type = isTransaction(message)
+        ? "TransactionPolicyActivation"
+        : "TransferPolicyActivation";
+    writeSignatureFile(out, await signMessage(admin, evm.deployment, { type, message }));
+    io.out(line("wrote", `${out}: \`policies activate\` sends it with the others`));
+    return 0;
+}
+export async function policiesActivate(io, flags, files) {
+    if (files.length === 0) {
+        io.err(USAGE);
+        return 1;
+    }
+    const evm = await evmChain(io, flags);
+    const signed = await loadSignatures(files, evm.deployment, ACTIVATIONS);
+    const message = signed[0].message;
+    const via = sender(io, flags, evm);
+    for (const text of [
+        ...(await activationLines(evm, message)),
+        ...(await signedByLines(evm, message.company, signed)),
+    ]) {
+        io.out(text);
+    }
+    const signatures = signed.map(({ signature }) => signature);
+    const call = isTransaction(message)
+        ? await activateTransactionPolicyCall(evm, { message, signatures })
+        : await activateTransferPolicyCall(evm, { message, signatures });
+    io.out(line("call", `${isTransaction(message) ? "activateTransactionPolicy" : "activateTransferPolicy"} on the policies helper ${call.to}`));
+    return await send(io, flags, { evm, via, call }, {
+        question: "Activate this policy?",
+        action: "activate it",
+    });
+}
+/** `policies deactivate <id> [<file>]`: one active admin's signature, this key's unless a file gives one. */
+export function policiesDeactivate(io, flags, policyId, files) {
+    if (!policyId) {
+        io.err(USAGE);
+        return 1;
+    }
+    return signOrSend(io, flags, {
+        type: "PolicyDeactivation",
+        files,
+        fresh: async (keys) => ({
+            company: pickCompany(keys, flags.company),
+            policyId,
+            authId: randomUUID(),
+        }),
+        matches: (message) => {
+            if (message.policyId !== policyId) {
+                throw new Error(`The files deactivate ${message.policyId}, not ${policyId}`);
+            }
+            if (files.length > 1) {
+                throw new Error("A deactivation takes one admin's signature: one file");
+            }
+        },
+        role: async (evm, message, me, signed) => {
+            if (signed.length > 0) {
+                return { not: "it takes one admin's signature, and the file has it" };
+            }
+            const seat = await requireAdmin(evm, cofundClientId(message.company), me);
+            return { as: `admin ${seat.userId}` };
+        },
+        lines: async (evm, message) => {
+            const policy = await readPolicy(evm.reader, evm.deployment, cofundClientId(message.company), message.policyId);
+            return [
+                line("policy", policy
+                    ? `${message.policyId}: "${policy.title}", ${policy.active ? "active" : "inactive"}`
+                    : `${message.policyId} (no such policy)`),
+            ];
+        },
+        build: (evm, message, [first]) => deactivatePolicyCall(evm, { message, signature: first.signature }),
+        entry: "deactivatePolicy on the policies helper",
+        question: `Deactivate policy ${policyId}?`,
+    });
+}