@getcofund/protocol 0.0.0 → 0.1.0

package/dist/evm/abis/vault.js

@@ -0,0 +1,444 @@
+// Generated from the Foundry artifact `out/CFHelpersVaultTemplatev1.sol/CFHelpersVaultTemplatev1.json`
+// of cofund-solidity. Do not hand-edit: re-run
+// `packages/protocol/scripts/gen-evm-abis.mjs` against a `forge build` of
+// the contracts instead.
+export const vaultAbi = [
+    {
+        type: "constructor",
+        inputs: [
+            {
+                name: "_expectedState",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "clientId",
+        inputs: [],
+        outputs: [
+            {
+                name: "",
+                type: "bytes32",
+                internalType: "bytes32",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "eip712Domain",
+        inputs: [],
+        outputs: [
+            {
+                name: "fields",
+                type: "bytes1",
+                internalType: "bytes1",
+            },
+            {
+                name: "name",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "version",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "chainId",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "verifyingContract",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "salt",
+                type: "bytes32",
+                internalType: "bytes32",
+            },
+            {
+                name: "extensions",
+                type: "uint256[]",
+                internalType: "uint256[]",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "executeTransaction",
+        inputs: [
+            {
+                name: "company",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "policyId",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "messageType",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "wrapper",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "func",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "instructions",
+                type: "bytes",
+                internalType: "bytes",
+            },
+            {
+                name: "allowances",
+                type: "tuple[]",
+                internalType: "struct CFHelpersVaultTemplatev1.Allowance[]",
+                components: [
+                    {
+                        name: "asset",
+                        type: "address",
+                        internalType: "address",
+                    },
+                    {
+                        name: "amount",
+                        type: "uint256",
+                        internalType: "uint256",
+                    },
+                ],
+            },
+            {
+                name: "authId",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "signatures",
+                type: "bytes[]",
+                internalType: "bytes[]",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "bool",
+                internalType: "bool",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "executeTransfer",
+        inputs: [
+            {
+                name: "company",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "policyId",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "messageType",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+                internalType: "uint256",
+            },
+            {
+                name: "token",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "recipient",
+                type: "address",
+                internalType: "address",
+            },
+            {
+                name: "authId",
+                type: "string",
+                internalType: "string",
+            },
+            {
+                name: "signatures",
+                type: "bytes[]",
+                internalType: "bytes[]",
+            },
+        ],
+        outputs: [
+            {
+                name: "",
+                type: "bool",
+                internalType: "bool",
+            },
+        ],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "expectedState",
+        inputs: [],
+        outputs: [
+            {
+                name: "",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "factory",
+        inputs: [],
+        outputs: [
+            {
+                name: "",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "function",
+        name: "initialize",
+        inputs: [
+            {
+                name: "_clientId",
+                type: "bytes32",
+                internalType: "bytes32",
+            },
+            {
+                name: "_state",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+        outputs: [],
+        stateMutability: "nonpayable",
+    },
+    {
+        type: "function",
+        name: "state",
+        inputs: [],
+        outputs: [
+            {
+                name: "",
+                type: "address",
+                internalType: "contract ICofundHelperState",
+            },
+        ],
+        stateMutability: "view",
+    },
+    {
+        type: "event",
+        name: "TransactionExecuted",
+        inputs: [
+            {
+                name: "policyId",
+                type: "string",
+                indexed: true,
+                internalType: "string",
+            },
+            {
+                name: "messageType",
+                type: "string",
+                indexed: false,
+                internalType: "string",
+            },
+            {
+                name: "func",
+                type: "string",
+                indexed: false,
+                internalType: "string",
+            },
+            {
+                name: "wrapper",
+                type: "address",
+                indexed: false,
+                internalType: "address",
+            },
+            {
+                name: "authId",
+                type: "string",
+                indexed: false,
+                internalType: "string",
+            },
+        ],
+        anonymous: false,
+    },
+    {
+        type: "event",
+        name: "TransferExecuted",
+        inputs: [
+            {
+                name: "policyId",
+                type: "string",
+                indexed: true,
+                internalType: "string",
+            },
+            {
+                name: "messageType",
+                type: "string",
+                indexed: false,
+                internalType: "string",
+            },
+            {
+                name: "amount",
+                type: "uint256",
+                indexed: false,
+                internalType: "uint256",
+            },
+            {
+                name: "token",
+                type: "address",
+                indexed: false,
+                internalType: "address",
+            },
+            {
+                name: "recipient",
+                type: "address",
+                indexed: false,
+                internalType: "address",
+            },
+            {
+                name: "authId",
+                type: "string",
+                indexed: false,
+                internalType: "string",
+            },
+        ],
+        anonymous: false,
+    },
+    {
+        type: "error",
+        name: "AlreadyInitialized",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "AmountExceedsPolicy",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "ECDSAInvalidSignature",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "ECDSAInvalidSignatureLength",
+        inputs: [
+            {
+                name: "length",
+                type: "uint256",
+                internalType: "uint256",
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "ECDSAInvalidSignatureS",
+        inputs: [
+            {
+                name: "s",
+                type: "bytes32",
+                internalType: "bytes32",
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "InactivePolicy",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidAmount",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidCompany",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidPolicyType",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidSignature",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidSigner",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidToken",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "InvalidType",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "RecipientNotAllowed",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "SafeERC20FailedOperation",
+        inputs: [
+            {
+                name: "token",
+                type: "address",
+                internalType: "address",
+            },
+        ],
+    },
+    {
+        type: "error",
+        name: "ThresholdNotMet",
+        inputs: [],
+    },
+    {
+        type: "error",
+        name: "UnauthorizedCaller",
+        inputs: [
+            {
+                name: "reason",
+                type: "string",
+                internalType: "string",
+            },
+        ],
+    },
+];

package/dist/evm/address.d.ts

@@ -0,0 +1,2 @@
+/** Whether two EVM addresses are the same, whatever their casing. */
+export declare function sameAddress(a: string, b: string): boolean;

package/dist/evm/address.js

@@ -0,0 +1,4 @@
+/** Whether two EVM addresses are the same, whatever their casing. */
+export function sameAddress(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}

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

@@ -0,0 +1,30 @@
+import type { Address, Hex } from "viem";
+import { type EvmReader } from "../chain.ts";
+import type { EvmDeployment } from "../deployment.ts";
+/** Where a call is built for: the deployment, and a reader on its chain. */
+export type EvmContext = {
+    deployment: EvmDeployment;
+    reader: EvmReader;
+};
+/** The clock a deadline is checked on: unix seconds; the chain's latest block when unset. */
+export type DeadlineOptions = {
+    now?: bigint;
+};
+/** A uint256 message field (decimal digits), as a bigint. */
+export declare function uint(value: string | number | bigint, what: string): bigint;
+/** `authId` is spent for the cofund: State's replay store reverts `KeyExists`. */
+export declare function requireAuthIdUnspent({ deployment, reader }: EvmContext, clientId: Hex, authId: string): Promise<void>;
+/** The errors a contract raises for a signer that is not an active admin, by case. */
+export type AdminErrors = {
+    /** The address holds no seat in the cofund. */
+    unknown: string;
+    inactive: string;
+    notAdmin: string;
+};
+/**
+ * `signer`'s seat, which must be an active admin's: its user id, or the
+ * contract's refusal for each way it is not.
+ */
+export declare function requireActiveAdmin({ deployment, reader }: EvmContext, clientId: Hex, signer: Address, errors: AdminErrors, what: string): Promise<string>;
+/** `Users._requireWindow`: open now, and at most `MAX_INVITE_LIFETIME` out. Both bounds inclusive. */
+export declare function requireWindow(reader: EvmReader, expiresAt: bigint, { now }: DeadlineOptions): Promise<void>;

package/dist/evm/calls/common.js

@@ -0,0 +1,51 @@
+import { readLatestTimestamp } from "../chain.js";
+import { readAuthIdSpent, readUser, readUserIdByAddress } from "../reads.js";
+import { refuse } from "../signatures.js";
+const UINT = /^\d{1,78}$/;
+/** A uint256 message field (decimal digits), as a bigint. */
+export function uint(value, what) {
+    if (typeof value === "bigint") {
+        return value;
+    }
+    const text = String(value);
+    if (!UINT.test(text)) {
+        throw new Error(`${what} is not a uint256: ${text}`);
+    }
+    return BigInt(text);
+}
+/** `authId` is spent for the cofund: State's replay store reverts `KeyExists`. */
+export async function requireAuthIdUnspent({ deployment, reader }, clientId, authId) {
+    if (await readAuthIdSpent(reader, deployment, clientId, authId)) {
+        refuse("KeyExists", `authId "${authId}" is already spent for this cofund`);
+    }
+}
+/**
+ * `signer`'s seat, which must be an active admin's: its user id, or the
+ * contract's refusal for each way it is not.
+ */
+export async function requireActiveAdmin({ deployment, reader }, clientId, signer, errors, what) {
+    const userId = await readUserIdByAddress(reader, deployment, clientId, signer);
+    if (userId === null) {
+        refuse(errors.unknown, `${what} ${signer} holds no seat in this cofund`);
+    }
+    const user = await readUser(reader, deployment, clientId, userId);
+    if (!user?.active) {
+        refuse(errors.inactive, `${what} ${signer} (${userId}) is not active`);
+    }
+    if (!user.isAdmin) {
+        refuse(errors.notAdmin, `${what} ${signer} (${userId}) is not an admin`);
+    }
+    return userId;
+}
+/** `Users._requireWindow`: open now, and at most `MAX_INVITE_LIFETIME` out. Both bounds inclusive. */
+export async function requireWindow(reader, expiresAt, { now }) {
+    const at = now ?? (await readLatestTimestamp(reader));
+    if (at > expiresAt) {
+        refuse("InviteExpired", `it expired at ${expiresAt}; it is ${at} now`);
+    }
+    if (expiresAt > at + MAX_INVITE_LIFETIME) {
+        refuse("InvalidParams", `it expires at ${expiresAt}, more than 30 days after ${at}`);
+    }
+}
+/** `CFHelpersUsersv1.MAX_INVITE_LIFETIME`. */
+const MAX_INVITE_LIFETIME = 30n * 24n * 60n * 60n;

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

@@ -0,0 +1,11 @@
+/**
+ * One builder per contract entry point, each returning the `{ to, data }`
+ * to submit, after checking it as the contract will: every signature
+ * recovers to the address State holds for its signer, the set meets the
+ * contract's rule, and a deadline is still open. A call the contract would
+ * revert is refused with a `CallRefusedError` naming its error.
+ */
+export type { DeadlineOptions, EvmContext } from "./common.ts";
+export { activateTransactionPolicyCall, activateTransferPolicyCall, deactivatePolicyCall, } from "./policies.ts";
+export { addUserCall, completeOnboardingCall, createClientCall, removeUserCall, rotateUserCall, } from "./users.ts";
+export { executeTransactionCall, executeTransferCall } from "./vault.ts";

package/dist/evm/calls/index.js

@@ -0,0 +1,4 @@
+// biome-ignore lint/performance/noBarrelFile: the calls' part of the `./evm` entry
+export { activateTransactionPolicyCall, activateTransferPolicyCall, deactivatePolicyCall, } from "./policies.js";
+export { addUserCall, completeOnboardingCall, createClientCall, removeUserCall, rotateUserCall, } from "./users.js";
+export { executeTransactionCall, executeTransferCall } from "./vault.js";

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

@@ -0,0 +1,25 @@
+import { type Hex } from "viem";
+import { type EvmCall } from "../chain.ts";
+import { type PolicyDeactivationMessage, type TransactionPolicyActivationMessage, type TransferPolicyActivationMessage } from "../eip712.ts";
+import { type EvmContext } from "./common.ts";
+/**
+ * `activateTransferPolicy`: a transfer policy (signers, threshold, token, cap,
+ * recipient allowlist), on active admins' `TransferPolicyActivation`.
+ */
+export declare function activateTransferPolicyCall(ctx: EvmContext, input: {
+    message: TransferPolicyActivationMessage;
+    signatures: Hex[];
+}): Promise<EvmCall>;
+/**
+ * `activateTransactionPolicy`: a transaction policy (signers, threshold, the
+ * wrapper and its function), on active admins' `TransactionPolicyActivation`.
+ */
+export declare function activateTransactionPolicyCall(ctx: EvmContext, input: {
+    message: TransactionPolicyActivationMessage;
+    signatures: Hex[];
+}): Promise<EvmCall>;
+/** `deactivatePolicy`: an active policy off, on one active admin's `PolicyDeactivation`. */
+export declare function deactivatePolicyCall(ctx: EvmContext, input: {
+    message: PolicyDeactivationMessage;
+    signature: Hex;
+}): Promise<EvmCall>;