@getcofund/protocol 0.0.0-stage → 0.1.0

package/dist/evm/calls/vault.js

@@ -0,0 +1,184 @@
+import { encodeFunctionData, erc20Abi, isAddressEqual, keccak256, zeroAddress, } from "viem";
+import { stateAbi } from "../abis/state.js";
+import { vaultAbi } from "../abis/vault.js";
+import { readContract } from "../chain.js";
+import { cofundClientId, TRANSACTION_TYPES, TRANSFER_TYPES, typedData, typedDataDigest, } from "../eip712.js";
+import { readClientVault, readPolicy } from "../reads.js";
+import { ascendingSigners, refuse } from "../signatures.js";
+import { requireAuthIdUnspent, uint } from "./common.js";
+/**
+ * A vault's calls (`CFHelpersVaultTemplatev1`), each checked as the vault
+ * and State would check it, then encoded for the cofund's vault. The vault
+ * accepts the guard, a Cofund admin or any active member of the cofund as the
+ * sender: that is the submitter's to be.
+ */
+/** The cofund's vault, which State names: there is no call without one. */
+async function vaultOf(ctx, clientId, company) {
+    const vault = await readClientVault(ctx.reader, ctx.deployment, clientId);
+    if (!vault) {
+        refuse("InvalidClient", `no cofund is named "${company}"`);
+    }
+    return vault;
+}
+/** The policy's checks both executions share: active, of this kind, of this type, signed often enough. */
+function checkPolicy(policy, message, { isTransaction, signatures }, more) {
+    if (!policy?.active) {
+        refuse("InactivePolicy", `policy ${message.policyId} is not active`);
+    }
+    if (policy.isTransaction !== isTransaction) {
+        refuse("InvalidType", `policy ${message.policyId} is a ${policy.isTransaction ? "transaction" : "transfer"} policy`);
+    }
+    more(policy);
+    if (policy.policyType !== message.messageType) {
+        refuse("InvalidPolicyType", `the message is a "${message.messageType}", the policy a "${policy.policyType}"`);
+    }
+    if (signatures < policy.threshold) {
+        refuse("ThresholdNotMet", `policy ${message.policyId} needs ${policy.threshold} signatures; ${signatures} given`);
+    }
+    return policy;
+}
+/**
+ * The signatures in the order the vault walks them, each by an active signer
+ * of the policy as State resolves them now (`resolvePolicySigner`).
+ */
+async function policySigners(ctx, clientId, policyId, digest, signatures) {
+    const ordered = await ascendingSigners(digest, signatures, {
+        what: "signature",
+        errors: "vault",
+    });
+    for (const { signer } of ordered) {
+        const [ok] = await readContract(ctx.reader, {
+            address: ctx.deployment.state,
+            abi: stateAbi,
+            functionName: "resolvePolicySigner",
+            args: [clientId, policyId, signer],
+        });
+        if (!ok) {
+            refuse("InvalidSigner", `${signer} is not an active signer of policy ${policyId}`);
+        }
+    }
+    return ordered.map(({ signature }) => signature);
+}
+/**
+ * `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 async function executeTransferCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message, signatures } = input;
+    const clientId = cofundClientId(message.company);
+    const amount = uint(message.amount, "amount");
+    const token = message.token;
+    const recipient = message.recipient;
+    const { vault, tier } = await vaultOf(ctx, clientId, message.company);
+    const policy = checkPolicy(await readPolicy(reader, deployment, clientId, message.policyId), message, { isTransaction: false, signatures: signatures.length }, ({ transfer }) => {
+        if (amount > transfer.maxAmount) {
+            refuse("AmountExceedsPolicy", `${amount} is over the policy's ${transfer.maxAmount}`);
+        }
+        if (!isAddressEqual(token, transfer.token)) {
+            refuse("InvalidToken", `the policy moves ${transfer.token}, not ${token}`);
+        }
+    });
+    const { recipients } = policy.transfer;
+    if (recipients.length > 0 &&
+        !recipients.some((r) => isAddressEqual(r, recipient))) {
+        refuse("RecipientNotAllowed", `${recipient} is not on the policy's allowlist`);
+    }
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    const ordered = await policySigners(ctx, clientId, message.policyId, typedDataDigest(typedData(deployment.eip712Domain, TRANSFER_TYPES, message)), signatures);
+    const [bps, balance] = await Promise.all([
+        readContract(reader, {
+            address: deployment.state,
+            abi: stateAbi,
+            functionName: "subscriptionTierBps",
+            args: [tier],
+        }),
+        readContract(reader, {
+            address: token,
+            abi: erc20Abi,
+            functionName: "balanceOf",
+            args: [vault],
+        }),
+    ]);
+    const raw = amount * BigInt(bps);
+    const fee = raw > 0n && raw / 10000n === 0n ? 1n : raw / 10000n;
+    if (fee !== 0n && balance < fee) {
+        refuse("fee transfer failed", `the vault holds ${balance}, under the fee of ${fee}`);
+    }
+    if (balance - fee < amount) {
+        refuse("ERC20 transfer failed", `the vault holds ${balance}, under ${amount}${fee === 0n ? "" : ` and the fee of ${fee}`}`);
+    }
+    return {
+        to: vault,
+        data: encodeFunctionData({
+            abi: vaultAbi,
+            functionName: "executeTransfer",
+            args: [
+                message.company,
+                message.policyId,
+                message.messageType,
+                amount,
+                token,
+                recipient,
+                message.authId,
+                ordered,
+            ],
+        }),
+    };
+}
+/**
+ * `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 async function executeTransactionCall(ctx, input) {
+    const { deployment, reader } = ctx;
+    const { message, instructions, signatures } = input;
+    const clientId = cofundClientId(message.company);
+    const wrapper = message.wrapper;
+    const { vault } = await vaultOf(ctx, clientId, message.company);
+    checkPolicy(await readPolicy(reader, deployment, clientId, message.policyId), message, { isTransaction: true, signatures: signatures.length }, ({ transaction }) => {
+        if (!isAddressEqual(wrapper, transaction.wrapper)) {
+            refuse("InvalidType", `the policy's wrapper is ${transaction.wrapper}, not ${wrapper}`);
+        }
+    });
+    await requireAuthIdUnspent(ctx, clientId, message.authId);
+    // The vault hashes the instructions it is given; signatures over another
+    // hash recover to strangers.
+    if (keccak256(instructions) !== message.instructionsHash.toLowerCase()) {
+        refuse("InvalidSigner", "the instructions are not the ones signed: their keccak256 is not the message's instructionsHash");
+    }
+    const ordered = await policySigners(ctx, clientId, message.policyId, typedDataDigest(typedData(deployment.eip712Domain, TRANSACTION_TYPES, message)), signatures);
+    const allowances = message.allowances.map((allowance, i) => {
+        const asset = allowance.asset;
+        const amount = uint(allowance.amount, `allowance ${i + 1}`);
+        if (isAddressEqual(asset, zeroAddress)) {
+            refuse("InvalidToken", `allowance ${i + 1} is of the zero address`);
+        }
+        if (amount === 0n) {
+            refuse("InvalidAmount", `allowance ${i + 1} is 0`);
+        }
+        return { asset, amount };
+    });
+    return {
+        to: vault,
+        data: encodeFunctionData({
+            abi: vaultAbi,
+            functionName: "executeTransaction",
+            args: [
+                message.company,
+                message.policyId,
+                message.messageType,
+                wrapper,
+                message.func,
+                instructions,
+                allowances,
+                message.authId,
+                ordered,
+            ],
+        }),
+    };
+}

package/dist/evm/chain.d.ts

@@ -0,0 +1,74 @@
+import { type Abi, type Account, type Address, type Chain, type ContractFunctionArgs, type ContractFunctionName, type ContractFunctionReturnType, type Hash, type Hex } from "viem";
+import type { TypedData } from "./eip712.ts";
+/**
+ * What the consumer brings to reach an EVM chain: a reader, a signer and a
+ * submitter. Each is a small structural type a viem client or account fits
+ * as it is.
+ */
+/**
+ * JSON-RPC reads: an EIP-1193 `request`. A viem `PublicClient` fits, as does
+ * any EIP-1193 provider; an ethers provider fits through
+ * `{ request: ({ method, params }) => provider.send(method, params) }`.
+ */
+export type EvmReader = {
+    request(args: {
+        method: string;
+        params?: unknown;
+    }): Promise<unknown>;
+};
+/**
+ * Signs EIP-712 typed data: a viem `Account` (a local key, a Ledger, a KMS
+ * adapter) as it is, or a viem `WalletClient` through `walletSigner`.
+ */
+export type TypedDataSigner = {
+    readonly address: Address;
+    signTypedData(data: TypedData): Promise<Hex>;
+};
+/** One call: where it goes and what it carries. Every call builder returns one. */
+export type EvmCall = {
+    to: Address;
+    data: Hex;
+    value?: bigint;
+};
+/** Sends a call and pays for it: `directSubmitter`, `guardSubmitter`, or the consumer's own (a gas manager). */
+export type EvmSubmitter = {
+    send(call: EvmCall): Promise<Hash>;
+};
+/**
+ * What a submitter needs of a wallet: a viem `WalletClient` with its account
+ * fits as it is.
+ */
+export type EvmWallet = {
+    readonly account: Account | undefined;
+    readonly chain: Chain | undefined;
+    sendTransaction(args: {
+        account: Account;
+        chain: Chain | null;
+        to: Address;
+        data: Hex;
+        value?: bigint;
+    }): Promise<Hash>;
+};
+/** A viem `WalletClient` as a `TypedDataSigner`: its account signs. */
+export declare function walletSigner(client: {
+    readonly account: Account | undefined;
+    signTypedData(args: TypedData & {
+        account: Account;
+    }): Promise<Hex>;
+}): TypedDataSigner;
+/** `eth_call` at the latest block: the return data. */
+export declare function ethCall(reader: EvmReader, call: {
+    to: Address;
+    data: Hex;
+}): Promise<Hex>;
+/** A view function of `abi` at `address`, read at the latest block and decoded. */
+export declare function readContract<const abi extends Abi, functionName extends ContractFunctionName<abi, "view" | "pure">, const args extends ContractFunctionArgs<abi, "view" | "pure", functionName>>(reader: EvmReader, read: {
+    address: Address;
+    abi: abi;
+    functionName: functionName;
+    args: args;
+}): Promise<ContractFunctionReturnType<abi, "view" | "pure", functionName, args>>;
+/** The chain id the reader is on. */
+export declare function readChainId(reader: EvmReader): Promise<number>;
+/** The latest block's timestamp, unix seconds: the clock a deadline is checked on. */
+export declare function readLatestTimestamp(reader: EvmReader): Promise<bigint>;

package/dist/evm/chain.js

@@ -0,0 +1,48 @@
+import { decodeFunctionResult, encodeFunctionData, } from "viem";
+/** A viem `WalletClient` as a `TypedDataSigner`: its account signs. */
+export function walletSigner(client) {
+    const account = client.account;
+    if (!account) {
+        throw new Error("The wallet client has no account to sign with");
+    }
+    return {
+        address: account.address,
+        signTypedData: (data) => client.signTypedData({ ...data, account }),
+    };
+}
+/** `eth_call` at the latest block: the return data. */
+export async function ethCall(reader, call) {
+    return (await reader.request({
+        method: "eth_call",
+        params: [call, "latest"],
+    }));
+}
+/** A view function of `abi` at `address`, read at the latest block and decoded. */
+export async function readContract(reader, read) {
+    const data = encodeFunctionData({
+        abi: read.abi,
+        functionName: read.functionName,
+        args: read.args,
+    });
+    const result = await ethCall(reader, { to: read.address, data });
+    return decodeFunctionResult({
+        abi: read.abi,
+        functionName: read.functionName,
+        data: result,
+    });
+}
+/** The chain id the reader is on. */
+export async function readChainId(reader) {
+    return Number(BigInt((await reader.request({ method: "eth_chainId" }))));
+}
+/** The latest block's timestamp, unix seconds: the clock a deadline is checked on. */
+export async function readLatestTimestamp(reader) {
+    const block = (await reader.request({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false],
+    }));
+    if (!block) {
+        throw new Error("The node returned no latest block");
+    }
+    return BigInt(block.timestamp);
+}

package/dist/evm/company-name.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Company-name normalization.
+ *
+ * The user types a free-form display name (spaces, mixed case). We derive a
+ * stable normalized identifier from it that seeds the on-chain client ID
+ * (`sha256(name)`) and enforces org uniqueness. This MUST stay deterministic
+ * and is shared between the client form (taken-check), the server action
+ * (the value actually persisted as `Company.name`) and the SDK (the `company`
+ * a founder signs), so it has no server deps.
+ */
+export declare const COMPANY_NAME_MIN_LENGTH = 3;
+export declare const COMPANY_NAME_MAX_LENGTH = 255;
+/**
+ * Lowercase, trim, collapse any run of non-alphanumeric characters into a
+ * single hyphen, and strip leading/trailing hyphens. Idempotent.
+ *
+ * Examples:
+ *   "Acme Corp"      -> "acme-corp"
+ *   "  Foo__Bar!! "  -> "foo-bar"
+ *   "acme-co"        -> "acme-co" (already-normalized handles are a no-op)
+ */
+export declare function normalizeCompanyName(input: string): string;
+/**
+ * Scope a normalized identifier to a deployment.
+ *
+ * `clientId = sha256(Company.name)` has no environment discriminator, so two
+ * deployments sharing a state contract derive the SAME clientId for the same
+ * org name. Prefixing the stored identifier separates them, and because every
+ * clientId in the app is derived from `Company.name`, doing it here covers all
+ * of those call sites without touching any of them.
+ *
+ * Pure and namespace-as-argument so it can be tested without env, and so the
+ * prefix cannot silently differ between the two places that must agree: the
+ * value persisted at signup, and the invite-link token the form previews.
+ *
+ * Idempotent for the same namespace, matching `normalizeCompanyName`, so
+ * re-applying it to an already-scoped identifier is a no-op.
+ */
+export declare function applyCompanyNamespace(normalized: string, namespace: string | null | undefined): string;
+/** A deployment's namespace as it prefixes `Company.name`: normalized; null when there is none. */
+export declare function normalizeCompanyNamespace(namespace: string | null | undefined): string | null;
+/**
+ * The `Company.name` a deployment with `namespace` stores for a cofund named
+ * `displayName`: the app's at signup, and the `company` a founder signs.
+ */
+export declare function companyIdentifierFor(displayName: string, namespace: string | null | undefined): string;

package/dist/evm/company-name.js

@@ -0,0 +1,64 @@
+/**
+ * Company-name normalization.
+ *
+ * The user types a free-form display name (spaces, mixed case). We derive a
+ * stable normalized identifier from it that seeds the on-chain client ID
+ * (`sha256(name)`) and enforces org uniqueness. This MUST stay deterministic
+ * and is shared between the client form (taken-check), the server action
+ * (the value actually persisted as `Company.name`) and the SDK (the `company`
+ * a founder signs), so it has no server deps.
+ */
+export const COMPANY_NAME_MIN_LENGTH = 3;
+export const COMPANY_NAME_MAX_LENGTH = 255;
+/**
+ * Lowercase, trim, collapse any run of non-alphanumeric characters into a
+ * single hyphen, and strip leading/trailing hyphens. Idempotent.
+ *
+ * Examples:
+ *   "Acme Corp"      -> "acme-corp"
+ *   "  Foo__Bar!! "  -> "foo-bar"
+ *   "acme-co"        -> "acme-co" (already-normalized handles are a no-op)
+ */
+export function normalizeCompanyName(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Scope a normalized identifier to a deployment.
+ *
+ * `clientId = sha256(Company.name)` has no environment discriminator, so two
+ * deployments sharing a state contract derive the SAME clientId for the same
+ * org name. Prefixing the stored identifier separates them, and because every
+ * clientId in the app is derived from `Company.name`, doing it here covers all
+ * of those call sites without touching any of them.
+ *
+ * Pure and namespace-as-argument so it can be tested without env, and so the
+ * prefix cannot silently differ between the two places that must agree: the
+ * value persisted at signup, and the invite-link token the form previews.
+ *
+ * Idempotent for the same namespace, matching `normalizeCompanyName`, so
+ * re-applying it to an already-scoped identifier is a no-op.
+ */
+export function applyCompanyNamespace(normalized, namespace) {
+    const prefix = normalizeCompanyNamespace(namespace);
+    if (!prefix) {
+        return normalized;
+    }
+    return normalized.startsWith(`${prefix}-`)
+        ? normalized
+        : `${prefix}-${normalized}`;
+}
+/** A deployment's namespace as it prefixes `Company.name`: normalized; null when there is none. */
+export function normalizeCompanyNamespace(namespace) {
+    return normalizeCompanyName(namespace ?? "") || null;
+}
+/**
+ * The `Company.name` a deployment with `namespace` stores for a cofund named
+ * `displayName`: the app's at signup, and the `company` a founder signs.
+ */
+export function companyIdentifierFor(displayName, namespace) {
+    return applyCompanyNamespace(normalizeCompanyName(displayName), namespace);
+}

package/dist/evm/deployment.d.ts

@@ -0,0 +1,47 @@
+import { type Address as AddressType } from "viem";
+import { z } from "zod";
+import { type EvmReader } from "./chain.ts";
+/** A `deployments/<chainId>.json`: the fields the package reads; any others (gov, sponsor, dates) pass unread. */
+export declare const EvmDeploymentSchema: z.ZodObject<{
+    chainId: z.ZodNumber;
+    state: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    users: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    policies: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    vaults: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    sponsorGuard: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    eip712Domain: z.ZodObject<{
+        name: z.ZodString;
+        version: z.ZodString;
+        chainId: z.ZodNumber;
+        verifyingContract: z.ZodPipe<z.ZodString, z.ZodTransform<`0x${string}`, string>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type EvmDeployment = {
+    chainId: number;
+    state: AddressType;
+    users: AddressType;
+    policies: AddressType;
+    vaults: AddressType;
+    sponsorGuard: AddressType;
+    eip712Domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: AddressType;
+    };
+};
+/** A deployment config that disagrees with itself or with its chain; `differences` says where. */
+export declare class DeploymentMismatchError extends Error {
+    readonly differences: string[];
+    constructor(differences: string[]);
+}
+/**
+ * `config` checked against itself and its chain, before anything is signed
+ * under it: the domain's chain id and verifying contract are the
+ * deployment's chain id and State; the reader is on that chain; each helper
+ * is the one State registers (the users and policies helpers, the guard, and
+ * the vault factory under `"vaults"`); and the domain's name and version are
+ * the ones the registered users helper reports (ERC-5267). A config that
+ * differs anywhere is refused with every difference.
+ */
+export declare function loadEvmDeployment(config: unknown, reader: EvmReader): Promise<EvmDeployment>;

package/dist/evm/deployment.js

@@ -0,0 +1,110 @@
+import { getAddress, isAddressEqual } from "viem";
+import { z } from "zod";
+import { usersAbi } from "./abis/users.js";
+import { readChainId, readContract } from "./chain.js";
+import { readHelperContract } from "./reads.js";
+import { Address } from "./types.js";
+/**
+ * A deployment of the contracts: the shape of cofund-solidity's
+ * `deployments/<chainId>.json`, which the deploy script writes. The package
+ * ships none; the consumer passes the one they deployed or trust.
+ */
+const ChecksummedAddress = Address.transform((a) => getAddress(a));
+/** A `deployments/<chainId>.json`: the fields the package reads; any others (gov, sponsor, dates) pass unread. */
+export const EvmDeploymentSchema = z.object({
+    chainId: z.number().int().positive(),
+    /** `CFHelpersStatev1`: the registry, and every message's verifying contract. */
+    state: ChecksummedAddress,
+    /** `CFHelpersUsersv1`, registered as `helperContracts("users")`. */
+    users: ChecksummedAddress,
+    /** `CFHelpersPoliciesv1`, registered as `helperContracts("policies")`. */
+    policies: ChecksummedAddress,
+    /** `CFHelpersVaultFactoryv1`, registered as `helperContracts("vaults")`. */
+    vaults: ChecksummedAddress,
+    /** `CFSponsorGuardv1`, registered as `helperContracts("sponsorGuard")`. */
+    sponsorGuard: ChecksummedAddress,
+    eip712Domain: z.object({
+        name: z.string(),
+        version: z.string(),
+        chainId: z.number().int().positive(),
+        verifyingContract: ChecksummedAddress,
+    }),
+});
+/** A deployment config that disagrees with itself or with its chain; `differences` says where. */
+export class DeploymentMismatchError extends Error {
+    differences;
+    constructor(differences) {
+        super(`The deployment does not match its chain: ${differences.join("; ")}`);
+        this.name = "DeploymentMismatchError";
+        this.differences = differences;
+    }
+}
+/** The config's address of each helper, by the key State registers it under. */
+const HELPERS = [
+    ["users", "users"],
+    ["policies", "policies"],
+    ["vaults", "vaults"],
+    ["sponsorGuard", "sponsorGuard"],
+];
+/**
+ * `config` checked against itself and its chain, before anything is signed
+ * under it: the domain's chain id and verifying contract are the
+ * deployment's chain id and State; the reader is on that chain; each helper
+ * is the one State registers (the users and policies helpers, the guard, and
+ * the vault factory under `"vaults"`); and the domain's name and version are
+ * the ones the registered users helper reports (ERC-5267). A config that
+ * differs anywhere is refused with every difference.
+ */
+export async function loadEvmDeployment(config, reader) {
+    const parsed = EvmDeploymentSchema.safeParse(config);
+    if (!parsed.success) {
+        throw new Error(`Not a deployment: ${parsed.error.issues
+            .map((issue) => `${issue.path.join(".") || "config"}: ${issue.message}`)
+            .join("; ")}`);
+    }
+    const deployment = parsed.data;
+    const { eip712Domain: domain } = deployment;
+    const differences = [];
+    if (domain.chainId !== deployment.chainId) {
+        differences.push(`eip712Domain.chainId is ${domain.chainId}, not the deployment's ${deployment.chainId}`);
+    }
+    if (!isAddressEqual(domain.verifyingContract, deployment.state)) {
+        differences.push(`eip712Domain.verifyingContract is ${domain.verifyingContract}, not State ${deployment.state}`);
+    }
+    const chainId = await readChainId(reader);
+    if (chainId !== deployment.chainId) {
+        differences.push(`the reader is on chain ${chainId}, not ${deployment.chainId}`);
+        throw new DeploymentMismatchError(differences);
+    }
+    let registered;
+    try {
+        registered = await Promise.all(HELPERS.map(([kind]) => readHelperContract(reader, deployment, kind)));
+    }
+    catch {
+        differences.push(`State at ${deployment.state} could not be read`);
+        throw new DeploymentMismatchError(differences);
+    }
+    HELPERS.forEach(([kind, field], i) => {
+        if (!isAddressEqual(registered[i], deployment[field])) {
+            differences.push(`${field} is ${deployment[field]}, but State registers ${registered[i]} as "${kind}"`);
+        }
+    });
+    const users = registered[0];
+    try {
+        const [, name, version, onChainId, verifyingContract] = await readContract(reader, { address: users, abi: usersAbi, functionName: "eip712Domain", args: [] });
+        if (name !== domain.name || version !== domain.version) {
+            differences.push(`eip712Domain is ("${domain.name}", "${domain.version}"), the contracts sign under ("${name}", "${version}")`);
+        }
+        if (Number(onChainId) !== deployment.chainId ||
+            !isAddressEqual(verifyingContract, deployment.state)) {
+            differences.push(`the users helper's domain is chain ${onChainId} and ${verifyingContract}`);
+        }
+    }
+    catch {
+        differences.push(`the users helper at ${users} reports no EIP-712 domain`);
+    }
+    if (differences.length > 0) {
+        throw new DeploymentMismatchError(differences);
+    }
+    return deployment;
+}