@getcofund/protocol 0.0.0-stage → 0.1.0

package/dist/evm/calls/policies.js

@@ -0,0 +1,173 @@
+import { encodeFunctionData, isAddressEqual, zeroAddress, } from "viem";
+import { policiesAbi } from "../abis/policies.js";
+import { stateAbi } from "../abis/state.js";
+import { readContract } from "../chain.js";
+import { cofundClientId, POLICY_DEACTIVATION_TYPES, TRANSACTION_POLICY_ACTIVATION_TYPES, TRANSFER_POLICY_ACTIVATION_TYPES, typedData, typedDataDigest, } from "../eip712.js";
+import { readPolicy, readRequiredPolicyActivationSignatures, readUser, } from "../reads.js";
+import { ascendingSigners, recoverSigner, refuse } from "../signatures.js";
+import { requireActiveAdmin, requireAuthIdUnspent, uint, } from "./common.js";
+/**
+ * What both activations check, in the helper's order: the type is supported,
+ * the shape holds, the `authId` is unspent, enough active admins signed
+ * (`requiredPolicyActivationSignatures`), and State accepts the policy. The
+ * signatures come back in the order the helper walks them.
+ */
+async function checkActivation(ctx, message, types, signatures, option) {
+    const { deployment, reader } = ctx;
+    const clientId = cofundClientId(message.company);
+    const threshold = uint(message.threshold, "threshold");
+    const supported = await readContract(reader, {
+        address: deployment.state,
+        abi: stateAbi,
+        functionName: "isSupportedType",
+        args: [message.policyType],
+    });
+    if (!supported) {
+        refuse("InvalidPolicyType", `State does not support "${message.policyType}"`);
+    }
+    if (message.title === "") {
+        refuse("InvalidTitle", "the title is empty");
+    }
+    if (threshold === 0n) {
+        refuse("InvalidThreshold", "the threshold is 0");
+    }
+    if (message.signerIds.length === 0 ||
+        BigInt(message.signerIds.length) < threshold) {
+        refuse("SignersLength", `${message.signerIds.length} signers cannot meet a threshold of ${threshold}`);
+    }
+    if (isAddressEqual(option.address, zeroAddress)) {
+        refuse("InvalidType", `the ${option.what} is the zero address`);
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    const required = await readRequiredPolicyActivationSignatures(reader, deployment, clientId, threshold);
+    if (signatures.length < required) {
+        refuse("SignerCountMismatch", `activating a ${threshold}-signature policy needs ${required} admin signatures; ${signatures.length} given`);
+    }
+    const digest = typedDataDigest(typedData(deployment.eip712Domain, types, message));
+    const ordered = await ascendingSigners(digest, signatures, {
+        what: "signature",
+    });
+    for (const { signer } of ordered) {
+        await requireActiveAdmin(ctx, clientId, signer, {
+            unknown: "InvalidSigner",
+            inactive: "InvalidSigner",
+            notAdmin: "InvalidSigner",
+        }, "signer");
+    }
+    if (await readPolicy(reader, deployment, clientId, message.policyId)) {
+        refuse("InvalidPolicy", `policy ${message.policyId} was already activated`);
+    }
+    const seen = new Set();
+    for (const signerId of message.signerIds) {
+        const user = await readUser(reader, deployment, clientId, signerId);
+        if (!user?.active) {
+            refuse("InvalidPolicySigner", `${signerId} is not an active user of this cofund`);
+        }
+        if (seen.has(signerId)) {
+            refuse("DuplicatePolicySigner", `${signerId} is listed twice`);
+        }
+        seen.add(signerId);
+    }
+    return {
+        clientId,
+        threshold,
+        ordered: ordered.map(({ signature }) => signature),
+    };
+}
+/**
+ * `activateTransferPolicy`: a transfer policy (signers, threshold, token, cap,
+ * recipient allowlist), on active admins' `TransferPolicyActivation`.
+ */
+export async function activateTransferPolicyCall(ctx, input) {
+    const { message } = input;
+    const { clientId, threshold, ordered } = await checkActivation(ctx, message, TRANSFER_POLICY_ACTIVATION_TYPES, input.signatures, { address: message.token, what: "token" });
+    for (const recipient of message.recipients) {
+        if (isAddressEqual(recipient, zeroAddress)) {
+            refuse("InvalidRecipient", "a recipient is the zero address");
+        }
+    }
+    return {
+        to: ctx.deployment.policies,
+        data: encodeFunctionData({
+            abi: policiesAbi,
+            functionName: "activateTransferPolicy",
+            args: [
+                {
+                    clientId,
+                    company: message.company,
+                    policyId: message.policyId,
+                    title: message.title,
+                    policyType: message.policyType,
+                    signerIds: message.signerIds,
+                    threshold,
+                    token: message.token,
+                    maxAmount: uint(message.maxAmount, "maxAmount"),
+                    recipients: message.recipients,
+                },
+                message.authId,
+                ordered,
+            ],
+        }),
+    };
+}
+/**
+ * `activateTransactionPolicy`: a transaction policy (signers, threshold, the
+ * wrapper and its function), on active admins' `TransactionPolicyActivation`.
+ */
+export async function activateTransactionPolicyCall(ctx, input) {
+    const { message } = input;
+    const { clientId, threshold, ordered } = await checkActivation(ctx, message, TRANSACTION_POLICY_ACTIVATION_TYPES, input.signatures, { address: message.wrapper, what: "wrapper" });
+    return {
+        to: ctx.deployment.policies,
+        data: encodeFunctionData({
+            abi: policiesAbi,
+            functionName: "activateTransactionPolicy",
+            args: [
+                {
+                    clientId,
+                    company: message.company,
+                    policyId: message.policyId,
+                    title: message.title,
+                    policyType: message.policyType,
+                    signerIds: message.signerIds,
+                    threshold,
+                    wrapper: message.wrapper,
+                    func: message.func,
+                },
+                message.authId,
+                ordered,
+            ],
+        }),
+    };
+}
+/** `deactivatePolicy`: an active policy off, on one active admin's `PolicyDeactivation`. */
+export async function deactivatePolicyCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message, signature } = input;
+    const clientId = cofundClientId(message.company);
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    const signer = await recoverSigner(typedDataDigest(typedData(deployment.eip712Domain, POLICY_DEACTIVATION_TYPES, message)), signature, { what: "the admin's signature" });
+    await requireActiveAdmin(ctx, clientId, signer, {
+        unknown: "UnauthorizedCaller",
+        inactive: "InactiveUser",
+        notAdmin: "InvalidAdmin",
+    }, "the signer");
+    const policy = await readPolicy(reader, deployment, clientId, message.policyId);
+    if (!policy?.active) {
+        refuse("InvalidPolicy", `policy ${message.policyId} is not active`);
+    }
+    return {
+        to: deployment.policies,
+        data: encodeFunctionData({
+            abi: policiesAbi,
+            functionName: "deactivatePolicy",
+            args: [
+                clientId,
+                message.company,
+                message.policyId,
+                message.authId,
+                signature,
+            ],
+        }),
+    };
+}

package/dist/evm/calls/users.d.ts

@@ -0,0 +1,61 @@
+import { type Address, type Hex } from "viem";
+import { type EvmCall } from "../chain.ts";
+import { type CompleteOnboardingMessage, type InviteUserMessage, type RemoveUserMessage, type RotateUserMessage } from "../eip712.ts";
+import { type DeadlineOptions, type EvmContext } from "./common.ts";
+/**
+ * `createClient`: a cofund and its founding admin, on the founder's own
+ * `InviteUser` over themselves (`callerId` and `userId` both the admin's id,
+ * an admin, position "admin"). Refused unless the window is open, the
+ * signature is the founder's, the `authId` is unspent, no cofund has this
+ * company yet and `tier` is one State knows.
+ */
+export declare function createClientCall(ctx: EvmContext, input: {
+    message: InviteUserMessage;
+    founder: Address;
+    signature: Hex;
+    /** A subscription tier State knows (`subscriptionTierExists`). */
+    tier: string;
+}, options?: DeadlineOptions): Promise<EvmCall>;
+/**
+ * `addUser`: a seat, on the inviting admin's `InviteUser`, co-signed by more
+ * admins for an admin seat (`requiredAdminInviteSignatures`, the inviter's
+ * own counted), and accepted by the invitee's key over the same message.
+ * Co-signatures are put in the order the helper walks them.
+ */
+export declare function addUserCall(ctx: EvmContext, input: {
+    message: InviteUserMessage;
+    adminSignature: Hex;
+    /** Other admins' signatures over the same message; read only for an admin seat. */
+    coSignatures?: Hex[];
+    invitee: Address;
+    inviteeSignature: Hex;
+}, options?: DeadlineOptions): Promise<EvmCall>;
+/**
+ * `removeUser`: a member out, on active admins' `RemoveUser`: one for a
+ * member, two for an admin while the cofund has more than one. Signatures are
+ * put in the order the helper walks them.
+ */
+export declare function removeUserCall(ctx: EvmContext, input: {
+    message: RemoveUserMessage;
+    signatures: Hex[];
+}): Promise<EvmCall>;
+/**
+ * `rotateUser`: a user's seat moved to a new key, which always signs
+ * `RotateUser`, and either the current key signs it too (`currentKeySignature`)
+ * or, for a lost key, active admins do (`adminSignatures`: two while the
+ * cofund has more than one admin), never both.
+ */
+export declare function rotateUserCall(ctx: EvmContext, input: {
+    message: RotateUserMessage;
+    newKeySignature: Hex;
+    currentKeySignature?: Hex;
+    adminSignatures?: Hex[];
+}): Promise<EvmCall>;
+/**
+ * `completeOnboarding`: the cofund's onboarding phase closed, on one active
+ * admin's `CompleteOnboarding`. Irreversible: refused once it is closed.
+ */
+export declare function completeOnboardingCall(ctx: EvmContext, input: {
+    message: CompleteOnboardingMessage;
+    signature: Hex;
+}): Promise<EvmCall>;

package/dist/evm/calls/users.js

@@ -0,0 +1,353 @@
+import { encodeFunctionData, isAddressEqual, zeroAddress, } from "viem";
+import { stateAbi } from "../abis/state.js";
+import { usersAbi } from "../abis/users.js";
+import { readContract } from "../chain.js";
+import { COMPLETE_ONBOARDING_TYPES, cofundClientId, INVITE_USER_TYPES, REMOVE_USER_TYPES, ROTATE_USER_TYPES, typedData, typedDataDigest, } from "../eip712.js";
+import { readActiveAdmins, readClientVault, readOnboardingComplete, readRequiredAdminInviteSignatures, readUser, readUserIdByAddress, } from "../reads.js";
+import { ascendingSigners, recoverSigner, refuse } from "../signatures.js";
+import { requireActiveAdmin, requireAuthIdUnspent, requireWindow, uint, } from "./common.js";
+/**
+ * The users helper's calls (`CFHelpersUsersv1`), each checked as the helper
+ * and State would check it, then encoded. None checks `msg.sender`, which is
+ * the submitter's: `createClient` and `addUser` only accept the sponsor guard
+ * or a Cofund admin as the sender (`_requirePlatform`), so they go through
+ * `guardSubmitter`; the rest accept anyone.
+ */
+/** `Users._requireSignerIsActiveAdmin`. */
+const ADMIN_SIGNER = {
+    unknown: "InvalidSigner",
+    inactive: "InactiveSigner",
+    notAdmin: "InvalidSigner",
+};
+function inviteDigest(ctx, message) {
+    return typedDataDigest(typedData(ctx.deployment.eip712Domain, INVITE_USER_TYPES, message));
+}
+/** `State.addUser` / `State.newClient`: the seat is free, and the address holds no other. */
+async function requireFreeSeat(ctx, clientId, userId, address) {
+    const { deployment, reader } = ctx;
+    if (await readUser(reader, deployment, clientId, userId)) {
+        refuse("UserExists", `user ${userId} already has a seat in this cofund`);
+    }
+    const holder = await readUserIdByAddress(reader, deployment, clientId, address);
+    if (holder !== null) {
+        refuse("AddressExists", `${address} already holds seat ${holder}`);
+    }
+}
+/**
+ * `createClient`: a cofund and its founding admin, on the founder's own
+ * `InviteUser` over themselves (`callerId` and `userId` both the admin's id,
+ * an admin, position "admin"). Refused unless the window is open, the
+ * signature is the founder's, the `authId` is unspent, no cofund has this
+ * company yet and `tier` is one State knows.
+ */
+export async function createClientCall(ctx, input, options = {}) {
+    const { deployment, reader } = ctx;
+    const { message, founder, signature, tier } = input;
+    const clientId = cofundClientId(message.company);
+    const expiresAt = uint(message.expiresAt, "expiresAt");
+    await requireWindow(reader, expiresAt, options);
+    if (message.authId === "") {
+        refuse("InvalidParams", "the authId is empty");
+    }
+    if (isAddressEqual(founder, zeroAddress)) {
+        refuse("InvalidParams", "the founder is the zero address");
+    }
+    if (message.callerId !== message.userId ||
+        !message.userIsAdmin ||
+        message.userPosition !== "admin") {
+        refuse("InvalidSignature", 'the founder signs InviteUser over themselves: callerId = userId, an admin, position "admin"');
+    }
+    const signer = await recoverSigner(inviteDigest(ctx, message), signature, {
+        what: "the founder's signature",
+    });
+    if (!isAddressEqual(signer, founder)) {
+        refuse("InvalidSignature", `the founder's signature is ${signer}'s`);
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    if (await readClientVault(reader, deployment, clientId)) {
+        refuse("ClientExists", `a cofund named "${message.company}" exists`);
+    }
+    const tierExists = await readContract(reader, {
+        address: deployment.state,
+        abi: stateAbi,
+        functionName: "subscriptionTierExists",
+        args: [tier],
+    });
+    if (!tierExists) {
+        refuse("InvalidTier", `State has no tier "${tier}"`);
+    }
+    await requireFreeSeat(ctx, clientId, message.userId, founder);
+    if (isAddressEqual(deployment.vaults, zeroAddress)) {
+        refuse("InvalidHelper", "no vault factory is registered");
+    }
+    return {
+        to: deployment.users,
+        data: encodeFunctionData({
+            abi: usersAbi,
+            functionName: "createClient",
+            args: [
+                clientId,
+                message.company,
+                message.userId,
+                founder,
+                tier,
+                expiresAt,
+                message.authId,
+                signature,
+            ],
+        }),
+    };
+}
+/**
+ * `addUser`: a seat, on the inviting admin's `InviteUser`, co-signed by more
+ * admins for an admin seat (`requiredAdminInviteSignatures`, the inviter's
+ * own counted), and accepted by the invitee's key over the same message.
+ * Co-signatures are put in the order the helper walks them.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the helper's checks, one by one in its order
+export async function addUserCall(ctx, input, options = {}) {
+    const { deployment, reader } = ctx;
+    const { message, adminSignature, invitee, inviteeSignature } = input;
+    const clientId = cofundClientId(message.company);
+    const expiresAt = uint(message.expiresAt, "expiresAt");
+    await requireWindow(reader, expiresAt, options);
+    if (message.authId === "") {
+        refuse("InvalidParams", "the authId is empty");
+    }
+    const digest = inviteDigest(ctx, message);
+    const inviter = await recoverSigner(digest, adminSignature, {
+        what: "the inviting admin's signature",
+    });
+    const derived = await readUserIdByAddress(reader, deployment, clientId, inviter);
+    if (derived === null || derived !== message.callerId) {
+        refuse("UnauthorizedCaller", `the inviting signature is ${inviter}'s, which is not ${message.callerId}'s seat`);
+    }
+    const admin = await readUser(reader, deployment, clientId, message.callerId);
+    if (!admin?.active) {
+        refuse("InactiveSigner", `the inviting admin ${message.callerId} is not active`);
+    }
+    if (!admin.isAdmin) {
+        refuse("InvalidSigner", `the inviter ${message.callerId} is not an admin`);
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    let coSignatures = input.coSignatures ?? [];
+    if (message.userIsAdmin) {
+        const required = await readRequiredAdminInviteSignatures(reader, deployment, clientId);
+        const ordered = await ascendingSigners(digest, coSignatures, {
+            what: "co-signature",
+        });
+        for (const { signer } of ordered) {
+            if (isAddressEqual(signer, inviter)) {
+                refuse("InvalidSignature", "the inviting admin also co-signed");
+            }
+            await requireActiveAdmin(ctx, clientId, signer, ADMIN_SIGNER, "co-signer");
+        }
+        if (ordered.length + 1 < required) {
+            refuse("ThresholdNotMet", `an admin seat needs ${required} admin signatures, the inviter's included; ${ordered.length + 1} given`);
+        }
+        coSignatures = ordered.map(({ signature }) => signature);
+    }
+    if (isAddressEqual(invitee, zeroAddress)) {
+        refuse("InvalidSignature", "the invitee is the zero address");
+    }
+    const accepted = await recoverSigner(digest, inviteeSignature, {
+        what: "the invitee's signature",
+    });
+    if (!isAddressEqual(accepted, invitee)) {
+        refuse("InvalidSignature", `the invitee's signature is ${accepted}'s, not ${invitee}'s`);
+    }
+    await requireFreeSeat(ctx, clientId, message.userId, invitee);
+    return {
+        to: deployment.users,
+        data: encodeFunctionData({
+            abi: usersAbi,
+            functionName: "addUser",
+            args: [
+                {
+                    clientId,
+                    company: message.company,
+                    callerId: message.callerId,
+                    userId: message.userId,
+                    isAdmin: message.userIsAdmin,
+                    userPosition: message.userPosition,
+                    expiresAt,
+                    authId: message.authId,
+                },
+                adminSignature,
+                coSignatures,
+                invitee,
+                inviteeSignature,
+            ],
+        }),
+    };
+}
+/**
+ * `removeUser`: a member out, on active admins' `RemoveUser`: one for a
+ * member, two for an admin while the cofund has more than one. Signatures are
+ * put in the order the helper walks them.
+ */
+export async function removeUserCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message } = input;
+    const clientId = cofundClientId(message.company);
+    if (message.authId === "") {
+        refuse("InvalidParams", "the authId is empty");
+    }
+    const [removed, admins] = await Promise.all([
+        readUser(reader, deployment, clientId, message.removedUserId),
+        readActiveAdmins(reader, deployment, clientId),
+    ]);
+    const required = removed?.isAdmin && admins > 1 ? 2 : 1;
+    if (input.signatures.length < required) {
+        refuse("ThresholdNotMet", `removing ${message.removedUserId} needs ${required} admin signatures; ${input.signatures.length} given`);
+    }
+    const digest = typedDataDigest(typedData(deployment.eip712Domain, REMOVE_USER_TYPES, message));
+    const ordered = await ascendingSigners(digest, input.signatures, {
+        what: "signature",
+    });
+    for (const { signer } of ordered) {
+        await requireActiveAdmin(ctx, clientId, signer, ADMIN_SIGNER, "signer");
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    if (!removed) {
+        refuse("InvalidAddress", `${message.removedUserId} has no seat in this cofund`);
+    }
+    if (!removed.active) {
+        refuse("InactiveUser", `${message.removedUserId} is already removed`);
+    }
+    if (removed.isAdmin && admins <= 1) {
+        refuse("InvalidSetting", `${message.removedUserId} is the last admin`);
+    }
+    return {
+        to: deployment.users,
+        data: encodeFunctionData({
+            abi: usersAbi,
+            functionName: "removeUser",
+            args: [
+                clientId,
+                message.company,
+                message.removedUserId,
+                message.authId,
+                ordered.map(({ signature }) => signature),
+            ],
+        }),
+    };
+}
+/**
+ * `rotateUser`: a user's seat moved to a new key, which always signs
+ * `RotateUser`, and either the current key signs it too (`currentKeySignature`)
+ * or, for a lost key, active admins do (`adminSignatures`: two while the
+ * cofund has more than one admin), never both.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the helper's checks, one by one in its order
+export async function rotateUserCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message, newKeySignature } = input;
+    const currentKeySignature = input.currentKeySignature ?? "0x";
+    let adminSignatures = input.adminSignatures ?? [];
+    const clientId = cofundClientId(message.company);
+    const newAddress = message.newAddress;
+    if (message.authId === "") {
+        refuse("InvalidParams", "the authId is empty");
+    }
+    if (isAddressEqual(newAddress, zeroAddress)) {
+        refuse("InvalidSignature", "the new address is the zero address");
+    }
+    const digest = typedDataDigest(typedData(deployment.eip712Domain, ROTATE_USER_TYPES, message));
+    const newKey = await recoverSigner(digest, newKeySignature, {
+        what: "the new key's signature",
+    });
+    if (!isAddressEqual(newKey, newAddress)) {
+        refuse("InvalidSignature", `the new key's signature is ${newKey}'s, not ${newAddress}'s`);
+    }
+    const user = await readUser(reader, deployment, clientId, message.userId);
+    if (currentKeySignature !== "0x") {
+        if (adminSignatures.length !== 0) {
+            refuse("InvalidParams", "the current key and admins cannot both authorize it");
+        }
+        if (!user?.active) {
+            refuse("InactiveSigner", `${message.userId} has no active seat`);
+        }
+        const current = await recoverSigner(digest, currentKeySignature, {
+            what: "the current key's signature",
+        });
+        if (!isAddressEqual(current, user.address)) {
+            refuse("InvalidSignature", `the current key's signature is ${current}'s; State holds ${user.address} for ${message.userId}`);
+        }
+    }
+    else {
+        const admins = await readActiveAdmins(reader, deployment, clientId);
+        const required = admins > 1 ? 2 : 1;
+        if (adminSignatures.length < required) {
+            refuse("ThresholdNotMet", `a rotation without the current key needs ${required} admin signatures; ${adminSignatures.length} given`);
+        }
+        const ordered = await ascendingSigners(digest, adminSignatures, {
+            what: "admin signature",
+        });
+        for (const { signer } of ordered) {
+            await requireActiveAdmin(ctx, clientId, signer, ADMIN_SIGNER, "signer");
+        }
+        adminSignatures = ordered.map(({ signature }) => signature);
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    if (!user) {
+        refuse("InvalidUser", `${message.userId} has no seat in this cofund`);
+    }
+    if (!user.active) {
+        refuse("InactiveUser", `${message.userId} is removed`);
+    }
+    const holder = await readUserIdByAddress(reader, deployment, clientId, newAddress);
+    if (holder !== null) {
+        refuse("AddressExists", `${newAddress} already holds seat ${holder}`);
+    }
+    return {
+        to: deployment.users,
+        data: encodeFunctionData({
+            abi: usersAbi,
+            functionName: "rotateUser",
+            args: [
+                clientId,
+                message.company,
+                message.userId,
+                newAddress,
+                message.authId,
+                currentKeySignature,
+                newKeySignature,
+                adminSignatures,
+            ],
+        }),
+    };
+}
+/**
+ * `completeOnboarding`: the cofund's onboarding phase closed, on one active
+ * admin's `CompleteOnboarding`. Irreversible: refused once it is closed.
+ */
+export async function completeOnboardingCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message, signature } = input;
+    const clientId = cofundClientId(message.company);
+    if (message.authId === "") {
+        refuse("InvalidParams", "the authId is empty");
+    }
+    const signer = await recoverSigner(typedDataDigest(typedData(deployment.eip712Domain, COMPLETE_ONBOARDING_TYPES, message)), signature, { what: "the admin's signature" });
+    await requireActiveAdmin(ctx, clientId, signer, {
+        unknown: "UnauthorizedCaller",
+        inactive: "InactiveSigner",
+        notAdmin: "InvalidSigner",
+    }, "the signer");
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    if (!(await readClientVault(reader, deployment, clientId))) {
+        refuse("InvalidClient", `no cofund is named "${message.company}"`);
+    }
+    if (await readOnboardingComplete(reader, deployment, clientId)) {
+        refuse("OnboardingAlreadyComplete", "the onboarding phase is already closed");
+    }
+    return {
+        to: deployment.users,
+        data: encodeFunctionData({
+            abi: usersAbi,
+            functionName: "completeOnboarding",
+            args: [clientId, message.company, message.authId, signature],
+        }),
+    };
+}

package/dist/evm/calls/vault.d.ts

@@ -0,0 +1,25 @@
+import { type Hex } from "viem";
+import { type EvmCall } from "../chain.ts";
+import { type TransactionMessage, type TransferMessage } from "../eip712.ts";
+import { type EvmContext } from "./common.ts";
+/**
+ * `executeTransfer`: tokens out of the vault under a transfer policy, on its
+ * signers' `Transfer`: within the cap, in the policy's token, to an allowed
+ * recipient, with the threshold met, and with the vault holding the amount
+ * and the fee the cofund's tier charges on top.
+ */
+export declare function executeTransferCall(ctx: EvmContext, input: {
+    message: TransferMessage;
+    signatures: Hex[];
+}): Promise<EvmCall>;
+/**
+ * `executeTransaction`: a call through the policy's wrapper, on its signers'
+ * `Transaction` over these `instructions`, with the threshold met and every
+ * allowance a non-zero amount of a real token. The vault does not compare
+ * `func` with the policy's; neither does this.
+ */
+export declare function executeTransactionCall(ctx: EvmContext, input: {
+    message: TransactionMessage;
+    instructions: Hex;
+    signatures: Hex[];
+}): Promise<EvmCall>;