getcofund 0.1.0 → 0.2.0

package/README.md

@@ -23,6 +23,9 @@ With npx, put `--` first when passing flags, or npm takes flags such as `--help`
 cofund keys init [--force]
 cofund me
 cofund invite accept [--invite <id>] [--company <name>]
+cofund invite create --email <email> --first-name <name> --last-name <name> --position <title> [--admin] [--chains A,B] [--yes]
+cofund policies create --vault <id> --name <name> --signers <id|email,...> --threshold <n>
+  (--token <address|BTC> --max-amount <base units> | --wrapper <address>) [--type <PolicyType>] [--yes]
 cofund requests [list]
 cofund requests show <id>
 cofund requests sign <id> [--yes]
@@ -61,6 +64,11 @@ It rebuilds the EIP-712 message itself under the pinned domain, signs locally, a
 
 What it takes from the server: which on-chain user id (EVM) or account xpub (BTC) belongs to which named policy signer, and an invite's `callerId` and `authId` (a wrong one only makes the chain refuse it). `approve` receives each signer with its id or xpub, so a script holding its own roster can check the pairing.
 
+An admin creates policies and invites with keys of their own:
+- `policies create` builds the activation from the flags: the signers by member id or email (an EVM activation names their `onchainId`, a BTC one their account xpubs), the threshold, and the token and cap per transfer in base units or the wrapper (function `entry`). A transfer policy is `Operational_Expense` and a call policy `Treasury_Management` unless `--type` says otherwise. It signs under the pinned domain and company, with the BTC key's Cofund leaf on a Bitcoin vault. The policy activates at once when one admin may activate it; otherwise it awaits the other admins as a `policy` request.
+- `invite create` asks which user id the email's seat registers (an existing account keeps its own), signs `InviteUser` on each of the cofund's EVM vault chains (or `--chains`), 29 days out, and sends the invite. A member seat is claimable at once; an admin seat awaits the other admins' co-signatures where the chain asks for them, one `invite` request per chain.
+- Both show what they will sign and ask, or take `--yes`.
+
 `stocks buy` quotes the pool, sets the minimum output 1% under the quote, signs the swap and proposes it on the cofund's Stocks policy. The other signers approve it in the app or with `requests sign`.
 
 ## SDK
@@ -97,6 +105,55 @@ for (const request of await api.requests(cofundId)) {
 
 `proposeTransfer` and `proposeCall` take an id the caller picks (`id`, `authId`); a retry with the same id returns the same request, so the client retries them on a lost response. `signTransferProposal` and `signCallProposal` sign the proposer's own intent.
 
+An admin's writes work the same way: `signPolicyCreation` and `signInviteCreation` build the activation or each chain's `InviteUser` from your inputs and sign it locally, and `createPolicy` and `createInvite` send it under the id you picked.
+
+```js
+import { randomUUID } from "node:crypto";
+import { signInviteCreation, signPolicyCreation } from "getcofund";
+
+const company = keystore.cofunds[cofundId].company;
+const signers = { evm: evmWallet(keystore), btc: btcMessageSigner(keystore) };
+const [vault] = await api.vaults(cofundId);
+const roster = await api.members(cofundId);
+
+const policy = await signPolicyCreation(
+  {
+    id: randomUUID(),
+    vault,
+    name: "Payouts",
+    type: "Operational_Expense",
+    signers: roster.filter((m) => m.isAdmin),
+    threshold: 2,
+    token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    maxAmount: "1000000000", // 1,000 USDC per transfer
+  },
+  company,
+  pins,
+  signers,
+);
+await api.createPolicy(cofundId, policy); // AWAITING_SIGNATURES, or active at once
+
+const id = randomUUID();
+const { userId } = await api.inviteUserId(cofundId, "nia@example.com");
+const invite = await signInviteCreation(
+  {
+    id,
+    callerId: me.id,
+    userId: userId ?? id,
+    email: "nia@example.com",
+    firstName: "Nia",
+    lastName: "Okafor",
+    position: "Treasurer",
+    isAdmin: false,
+    chains: ["ETHEREUM", "ROBINHOOD"],
+  },
+  company,
+  pins,
+  signers.evm,
+);
+await api.createInvite(cofundId, invite);
+```
+
 ## Webhooks
 
 `cofund webhooks add https://bot.example.com/cofund` subscribes an endpoint for your key's agent, to every event or those named with `--events`, and prints its signing secret once. The URL must be https, on a host that resolves only to public addresses.

package/dist/api-types.d.ts

@@ -73,6 +73,13 @@ export declare const PolicyTypeSchema: z.ZodEnum<{
     Treasury_Management: "Treasury_Management";
 }>;
 export type PolicyType = z.infer<typeof PolicyTypeSchema>;
+/** The types the API lists and creates: not the app's own deposit and invoice policies. */
+export declare const ApiPolicyTypeSchema: z.ZodEnum<{
+    Contractor_Stipend: "Contractor_Stipend";
+    Operational_Expense: "Operational_Expense";
+    Treasury_Management: "Treasury_Management";
+}>;
+export type ApiPolicyType = z.infer<typeof ApiPolicyTypeSchema>;
 export declare const PolicyStatusSchema: z.ZodEnum<{
     PENDING: "PENDING";
     ACTIVE: "ACTIVE";
@@ -431,6 +438,7 @@ export declare const ApiPolicySchema: z.ZodObject<{
 export type ApiPolicy = z.infer<typeof ApiPolicySchema>;
 export declare const ApiMemberSchema: z.ZodObject<{
     id: z.ZodUUID;
+    onchainId: z.ZodUUID;
     email: z.ZodEmail;
     name: z.ZodNullable<z.ZodString>;
     isAdmin: z.ZodBoolean;
@@ -1455,6 +1463,199 @@ export declare const ProposeCallRequestSchema: z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ProposeCallRequest = z.infer<typeof ProposeCallRequestSchema>;
+/** An EVM transfer policy: the token and the cap per transfer, with the creator's `TransferPolicyActivation`. */
+export declare const CreateEvmTransferPolicyRequestSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ETHEREUM: "ETHEREUM";
+        BASE: "BASE";
+        ARBITRUM: "ARBITRUM";
+        ROBINHOOD: "ROBINHOOD";
+    }>;
+    token: z.ZodString;
+    maxAmount: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>;
+/** An EVM call policy: the wrapper it binds (function `entry`), with the creator's `TransactionPolicyActivation`. */
+export declare const CreateEvmCallPolicyRequestSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        ETHEREUM: "ETHEREUM";
+        BASE: "BASE";
+        ARBITRUM: "ARBITRUM";
+        ROBINHOOD: "ROBINHOOD";
+    }>;
+    wrapper: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>;
+/**
+ * A BTC transfer policy, with the creator's approval: a Bitcoin Signed Message
+ * over the activation digest (`btc-policy-activation.ts`) by their BTC key's
+ * Cofund leaf.
+ */
+export declare const CreateBtcPolicyRequestSchema: z.ZodObject<{
+    chain: z.ZodLiteral<"BTC">;
+    token: z.ZodLiteral<"BTC">;
+    maxAmount: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>;
+/** POST /policies (admins). Retrying with the same `id` returns the same policy. */
+export declare const CreatePolicyRequestSchema: z.ZodUnion<readonly [z.ZodObject<{
+    chain: z.ZodEnum<{
+        ETHEREUM: "ETHEREUM";
+        BASE: "BASE";
+        ARBITRUM: "ARBITRUM";
+        ROBINHOOD: "ROBINHOOD";
+    }>;
+    token: z.ZodString;
+    maxAmount: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodEnum<{
+        ETHEREUM: "ETHEREUM";
+        BASE: "BASE";
+        ARBITRUM: "ARBITRUM";
+        ROBINHOOD: "ROBINHOOD";
+    }>;
+    wrapper: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodLiteral<"BTC">;
+    token: z.ZodLiteral<"BTC">;
+    maxAmount: z.ZodString;
+    signature: z.ZodString;
+    id: z.ZodUUID;
+    vaultId: z.ZodUUID;
+    name: z.ZodString;
+    type: z.ZodEnum<{
+        Contractor_Stipend: "Contractor_Stipend";
+        Operational_Expense: "Operational_Expense";
+        Treasury_Management: "Treasury_Management";
+    }>;
+    signers: z.ZodArray<z.ZodUUID>;
+    threshold: z.ZodNumber;
+}, z.core.$strict>]>;
+export type CreatePolicyRequest = z.infer<typeof CreatePolicyRequestSchema>;
+/** POST /invites/user-id (admins). */
+export declare const InviteUserIdRequestSchema: z.ZodObject<{
+    email: z.ZodEmail;
+}, z.core.$strip>;
+export type InviteUserIdRequest = z.infer<typeof InviteUserIdRequestSchema>;
+/**
+ * The id an invite to that email must seat: the account's own when the email
+ * has one (its identity in every cofund), else null, and the invite seats its
+ * own `id`.
+ */
+export declare const InviteUserIdSchema: z.ZodObject<{
+    userId: z.ZodNullable<z.ZodUUID>;
+}, z.core.$strip>;
+export type InviteUserId = z.infer<typeof InviteUserIdSchema>;
+/** POST /invites (admins). Retrying with the same `id` returns the same invite. */
+export declare const CreateInviteRequestSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    email: z.ZodEmail;
+    firstName: z.ZodString;
+    lastName: z.ZodString;
+    position: z.ZodString;
+    isAdmin: z.ZodBoolean;
+    userId: z.ZodUUID;
+    chains: z.ZodArray<z.ZodObject<{
+        chain: z.ZodEnum<{
+            ETHEREUM: "ETHEREUM";
+            BASE: "BASE";
+            ARBITRUM: "ARBITRUM";
+            ROBINHOOD: "ROBINHOOD";
+        }>;
+        expiresAt: z.ZodString;
+        signature: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type CreateInviteRequest = z.infer<typeof CreateInviteRequestSchema>;
+/**
+ * An invite as created: the seat, and its row on each chain. A row is
+ * claimable (AWAITING_SUBMISSION), or an admin seat awaiting the other admins'
+ * co-signatures (AWAITING_SIGNATURES), when its id is the `invite` request
+ * they sign.
+ */
+export declare const ApiCreatedInviteSchema: z.ZodObject<{
+    id: z.ZodUUID;
+    cofundId: z.ZodUUID;
+    member: z.ZodObject<{
+        id: z.ZodUUID;
+        email: z.ZodEmail;
+        isAdmin: z.ZodBoolean;
+        position: z.ZodString;
+    }, z.core.$strip>;
+    chains: z.ZodArray<z.ZodObject<{
+        chain: z.ZodEnum<{
+            ETHEREUM: "ETHEREUM";
+            BASE: "BASE";
+            ARBITRUM: "ARBITRUM";
+            ROBINHOOD: "ROBINHOOD";
+        }>;
+        id: z.ZodUUID;
+        status: z.ZodEnum<{
+            FAILED: "FAILED";
+            AWAITING_SIGNATURES: "AWAITING_SIGNATURES";
+            COMPLETED: "COMPLETED";
+            AWAITING_SUBMISSION: "AWAITING_SUBMISSION";
+            PROCESSING: "PROCESSING";
+            EXPIRED: "EXPIRED";
+            CANCELED: "CANCELED";
+            REJECTED: "REJECTED";
+        }>;
+        expiresAt: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ApiCreatedInvite = z.infer<typeof ApiCreatedInviteSchema>;
 /** POST /requests/{id}/signatures. A BTC policy approval is a compact signature; the rest are EIP-712. */
 export declare const SignatureRequestSchema: z.ZodObject<{
     signature: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;

package/dist/api-types.js

@@ -111,6 +111,11 @@ export const PolicyTypeSchema = z.enum([
     "Operational_Expense",
     "Treasury_Management",
 ]);
+/** The types the API lists and creates: not the app's own deposit and invoice policies. */
+export const ApiPolicyTypeSchema = PolicyTypeSchema.exclude([
+    "Crypto_Onramp",
+    "Business_Invoice",
+]);
 export const PolicyStatusSchema = z.enum([
     "PENDING",
     "ACTIVE",
@@ -290,11 +295,8 @@ export const ApiPolicySchema = z
     .object({
     id: Uuid,
     name: PolicyName,
-    /**
-     * The `messageType` every request under it signs. The app's own deposit
-     * and invoice policies are not listed, as in the app.
-     */
-    type: PolicyTypeSchema.exclude(["Crypto_Onramp", "Business_Invoice"]),
+    /** The `messageType` every request under it signs. */
+    type: ApiPolicyTypeSchema,
     status: PolicyStatusSchema,
     threshold: Threshold,
     vault: ApiVaultSchema,
@@ -312,6 +314,8 @@ export const ApiPolicySchema = z
     recipients.every((recipient) => BtcAddress.safeParse(recipient).success), "A BTC policy's recipients are Bitcoin addresses");
 export const ApiMemberSchema = z.object({
     id: Uuid,
+    /** The id the member is registered under on chain here: what an EVM policy activation names. */
+    onchainId: Uuid,
     email: z.email(),
     name: PersonName.nullable(),
     isAdmin: z.boolean(),
@@ -524,6 +528,121 @@ export const ProposeCallRequestSchema = z.object({
     signature: Signature,
     name: RequestName.optional(),
 });
+/** A policy's cap per transfer: base units, at most 30 digits, as the app stores it. */
+const PolicyCap = PositiveBaseUnits.max(30, "at most 30 digits");
+const CreatePolicyCommon = {
+    /** A UUID the caller picks: the policy's id, and the `policyId` and `authId` its activation signs. */
+    id: Uuid,
+    vaultId: Uuid,
+    name: PolicyName,
+    type: ApiPolicyTypeSchema,
+    /** Members' ids. The activation names each one's `onchainId` (EVM) or account xpub (BTC). */
+    signers: z
+        .array(Uuid)
+        .min(1)
+        .max(100)
+        .refine((ids) => distinct(ids, (id) => id), "Each signer once"),
+    threshold: Threshold,
+};
+/** An EVM transfer policy: the token and the cap per transfer, with the creator's `TransferPolicyActivation`. */
+export const CreateEvmTransferPolicyRequestSchema = z
+    .object({
+    ...CreatePolicyCommon,
+    chain: EvmChainNameSchema,
+    token: Address,
+    maxAmount: PolicyCap,
+    signature: Signature,
+})
+    .strict();
+/** An EVM call policy: the wrapper it binds (function `entry`), with the creator's `TransactionPolicyActivation`. */
+export const CreateEvmCallPolicyRequestSchema = z
+    .object({
+    ...CreatePolicyCommon,
+    chain: EvmChainNameSchema,
+    wrapper: Address,
+    signature: Signature,
+})
+    .strict();
+/**
+ * A BTC transfer policy, with the creator's approval: a Bitcoin Signed Message
+ * over the activation digest (`btc-policy-activation.ts`) by their BTC key's
+ * Cofund leaf.
+ */
+export const CreateBtcPolicyRequestSchema = z
+    .object({
+    ...CreatePolicyCommon,
+    chain: z.literal("BTC"),
+    token: z.literal("BTC"),
+    maxAmount: PolicyCap,
+    signature: BtcMessageSignature,
+})
+    .strict();
+/** POST /policies (admins). Retrying with the same `id` returns the same policy. */
+export const CreatePolicyRequestSchema = z
+    .union([
+    CreateEvmTransferPolicyRequestSchema,
+    CreateEvmCallPolicyRequestSchema,
+    CreateBtcPolicyRequestSchema,
+])
+    .refine(({ threshold, signers }) => threshold <= signers.length, {
+    message: "The threshold is more than the signers",
+    path: ["threshold"],
+});
+/** A first or last name, as the invite form takes it. */
+const NamePart = z.string().min(2).max(100);
+const EmailAddress = z.email().max(254);
+/** POST /invites/user-id (admins). */
+export const InviteUserIdRequestSchema = z.object({ email: EmailAddress });
+/**
+ * The id an invite to that email must seat: the account's own when the email
+ * has one (its identity in every cofund), else null, and the invite seats its
+ * own `id`.
+ */
+export const InviteUserIdSchema = z.object({ userId: Uuid.nullable() });
+/** POST /invites (admins). Retrying with the same `id` returns the same invite. */
+export const CreateInviteRequestSchema = z.object({
+    /** A UUID the caller picks: the invite's id, and the `authId` every chain's `InviteUser` signs. */
+    id: Uuid,
+    email: EmailAddress,
+    firstName: NamePart,
+    lastName: NamePart,
+    /** The seat's position, signed as `userPosition`. */
+    position: Position.min(2),
+    isAdmin: z.boolean(),
+    /** The `userId` signed: POST /invites/user-id's answer, else `id`. */
+    userId: Uuid,
+    /** The inviting admin's `InviteUser` on each EVM chain. */
+    chains: z
+        .array(z.object({
+        chain: EvmChainNameSchema,
+        expiresAt: UnixSeconds,
+        signature: Signature,
+    }))
+        .min(1)
+        .refine((chains) => distinct(chains, ({ chain }) => chain), "One signature per chain"),
+});
+/**
+ * An invite as created: the seat, and its row on each chain. A row is
+ * claimable (AWAITING_SUBMISSION), or an admin seat awaiting the other admins'
+ * co-signatures (AWAITING_SIGNATURES), when its id is the `invite` request
+ * they sign.
+ */
+export const ApiCreatedInviteSchema = z.object({
+    id: Uuid,
+    cofundId: Uuid,
+    member: z.object({
+        id: Uuid,
+        email: z.email(),
+        isAdmin: z.boolean(),
+        position: Position,
+    }),
+    chains: z.array(z.object({
+        chain: EvmChainNameSchema,
+        id: Uuid,
+        status: InviteStatusSchema,
+        expiresAt: UnixSeconds,
+    })),
+});
 /** POST /requests/{id}/signatures. A BTC policy approval is a compact signature; the rest are EIP-712. */
 export const SignatureRequestSchema = z.object({
     signature: z.union([Signature, BtcMessageSignature]),

package/dist/cli/context.d.ts

@@ -10,7 +10,7 @@ export type CliIo = {
     /** Ask a yes/no question; absent when nobody can answer (no TTY). */
     confirm?: (question: string) => Promise<boolean>;
 };
-export declare const USAGE = "usage:\n  cofund --help\n  cofund keys init [--force]\n  cofund me\n  cofund invite accept [--invite <id>] [--company <name>]\n  cofund requests [list] [--cofund <id>]\n  cofund requests show <id> [--cofund <id>]\n  cofund requests sign <id> [--yes] [--cofund <id>]\n  cofund requests reject <id> [--yes] [--cofund <id>]\n  cofund stocks buy <SYMBOL> --spend <USDG> [--policy <id>] [--cofund <id>]\n  cofund webhooks [list]\n  cofund webhooks add <url> [--events a,b]\n  cofund webhooks remove <id>";
+export declare const USAGE = "usage:\n  cofund --help\n  cofund keys init [--force]\n  cofund me\n  cofund invite accept [--invite <id>] [--company <name>]\n  cofund invite create --email <email> --first-name <name> --last-name <name>\n    --position <title> [--admin] [--chains A,B] [--yes] [--cofund <id>]\n  cofund policies create --vault <id> --name <name> --signers <id|email,...>\n    --threshold <n> (--token <address|BTC> --max-amount <base units> |\n    --wrapper <address>) [--type <PolicyType>] [--yes] [--cofund <id>]\n  cofund requests [list] [--cofund <id>]\n  cofund requests show <id> [--cofund <id>]\n  cofund requests sign <id> [--yes] [--cofund <id>]\n  cofund requests reject <id> [--yes] [--cofund <id>]\n  cofund stocks buy <SYMBOL> --spend <USDG> [--policy <id>] [--cofund <id>]\n  cofund webhooks [list]\n  cofund webhooks add <url> [--events a,b]\n  cofund webhooks remove <id>";
 export declare function keystorePath(io: CliIo, flag?: string): string;
 export declare function client(io: CliIo): CofundClient;
 export declare function chainPins(io: CliIo): ChainPins;

package/dist/cli/context.js

@@ -7,6 +7,11 @@ export const USAGE = `usage:
   cofund keys init [--force]
   cofund me
   cofund invite accept [--invite <id>] [--company <name>]
+  cofund invite create --email <email> --first-name <name> --last-name <name>
+    --position <title> [--admin] [--chains A,B] [--yes] [--cofund <id>]
+  cofund policies create --vault <id> --name <name> --signers <id|email,...>
+    --threshold <n> (--token <address|BTC> --max-amount <base units> |
+    --wrapper <address>) [--type <PolicyType>] [--yes] [--cofund <id>]
   cofund requests [list] [--cofund <id>]
   cofund requests show <id> [--cofund <id>]
   cofund requests sign <id> [--yes] [--cofund <id>]

package/dist/cli/invite.d.ts

@@ -1,6 +1,15 @@
-import { type CliIo } from "./context.ts";
+import { type CliIo, type CofundValues } from "./context.ts";
 export declare function inviteAccept(io: CliIo, values: {
     keystore?: string;
     invite?: string;
     company?: string;
 }): Promise<number>;
+export type InviteCreateValues = CofundValues & {
+    email?: string;
+    "first-name"?: string;
+    "last-name"?: string;
+    position?: string;
+    admin?: boolean;
+    chains?: string;
+};
+export declare function inviteCreate(io: CliIo, values: InviteCreateValues): Promise<number>;

package/dist/cli/invite.js

@@ -1,7 +1,13 @@
-import { checkInvite, signInviteAcceptance } from "../invite.js";
+import { randomUUID } from "node:crypto";
+import { EvmChainNameSchema, } from "../api-types.js";
+import { checkInvite, signInviteAcceptance, signInviteCreation, } from "../invite.js";
 import { btcOwnershipProof, evmWallet, readKeystore, writeKeystore, } from "../keys.js";
-import { chainPins, client, keystorePath } from "./context.js";
-/** `cofund invite accept`: check the invite, pin the company, sign with the local keys. */
+import { approval, chainPins, client, keystorePath, pickCofund, pinnedCompany, USAGE, } from "./context.js";
+/**
+ * `cofund invite accept`: check the invite, pin the company, sign with the
+ * local keys. `cofund invite create`: an admin invites a member, signing each
+ * chain's seat with the local key.
+ */
 function inviteLines(invite) {
     const [first] = invite.chains;
     const expires = new Date(Number(first.message.expiresAt) * 1000);
@@ -85,3 +91,75 @@ export async function inviteAccept(io, values) {
     });
     return 0;
 }
+/** --chains, or every EVM chain the cofund has a vault on. */
+async function inviteChains(api, cofundId, flag) {
+    if (flag) {
+        return flag.split(",").map((chain) => EvmChainNameSchema.parse(chain));
+    }
+    const chains = new Set();
+    for (const { chain } of await api.vaults(cofundId)) {
+        if (chain !== "BTC") {
+            chains.add(chain);
+        }
+    }
+    return [...chains];
+}
+function newInviteLines(invite, company) {
+    return [
+        `invite    ${invite.firstName} ${invite.lastName} <${invite.email}>`,
+        `seat      ${invite.isAdmin ? "admin" : "member"}, ${invite.position}`,
+        `chains    ${invite.chains.join(", ")}`,
+        `company   "${company}"`,
+    ];
+}
+export async function inviteCreate(io, values) {
+    const { email, position } = values;
+    const firstName = values["first-name"];
+    const lastName = values["last-name"];
+    if (!(email && firstName && lastName && position)) {
+        io.err(USAGE);
+        return 1;
+    }
+    const keystore = readKeystore(keystorePath(io, values.keystore));
+    const api = client(io);
+    const me = await api.me();
+    const cofundId = pickCofund(me, values.cofund);
+    const company = pinnedCompany(keystore, cofundId);
+    const chains = await inviteChains(api, cofundId, values.chains);
+    if (chains.length === 0) {
+        io.err("The cofund has no EVM vault to seat a member on");
+        return 1;
+    }
+    const id = randomUUID();
+    const { userId } = await api.inviteUserId(cofundId, email);
+    const invite = {
+        id,
+        callerId: me.id,
+        userId: userId ?? id,
+        email,
+        firstName,
+        lastName,
+        position,
+        isAdmin: Boolean(values.admin),
+        chains,
+    };
+    for (const line of newInviteLines(invite, company)) {
+        io.out(line);
+    }
+    const approve = approval(io, values.yes, "Sign and send this invite?");
+    if (!approve) {
+        io.err("Pass --yes to invite without a prompt");
+        return 1;
+    }
+    if (!(await approve())) {
+        io.err("Not invited");
+        return 1;
+    }
+    const body = await signInviteCreation(invite, company, chainPins(io), evmWallet(keystore));
+    const created = await api.createInvite(cofundId, body);
+    io.out(`invited   ${created.member.email} (${created.id})`);
+    for (const row of created.chains) {
+        io.out(`${row.chain.padEnd(9)} ${row.id}  ${row.status}`);
+    }
+    return 0;
+}

package/dist/cli/policies.d.ts

@@ -0,0 +1,17 @@
+import { type CliIo, type CofundValues } from "./context.ts";
+export type PolicyValues = CofundValues & {
+    vault?: string;
+    name?: string;
+    type?: string;
+    signers?: string;
+    threshold?: string;
+    token?: string;
+    "max-amount"?: string;
+    wrapper?: string;
+};
+/**
+ * `cofund policies create`: build the policy's activation from the flags, sign
+ * it with the local key and create the policy. It activates at once when one
+ * admin may activate it, else it awaits the other admins.
+ */
+export declare function policiesCreate(io: CliIo, values: PolicyValues): Promise<number>;