@rubicon-caliga/agent-sdk 0.1.0 → 0.1.2

package/dist/payment-engine.js

@@ -1,7 +1,3 @@
-import { x402Client } from "@x402/core/client";
-import { registerBatchScheme } from "@circle-fin/x402-batching/client";
-import { ExactEvmScheme } from "@x402/evm/exact/client";
-import { privateKeyToAccount } from "viem/accounts";
 /**
  * Development engine. Declares the one-word amount without settling real funds,
  * for use against a dev-mode gateway. NOT for production.
@@ -23,35 +19,4 @@ export class StaticPaymentEngine {
         };
     }
 }
-/**
- * Circle/x402 engine. Signs the gateway's one-word `paymentRequired` terms.
- * Circle may batch settlement internally, but each signed payload corresponds to
- * exactly one word.
- */
-export class CircleGatewayPaymentEngine {
-    options;
-    client = new x402Client();
-    account;
-    constructor(options) {
-        this.options = options;
-        this.account = privateKeyToAccount(this.options.privateKey);
-        // Recommended buyer integration (Circle x402 buyer how-to): register the
-        // gasless batched scheme with an `exact` fallback. `registerBatchScheme`
-        // wires a CompositeEvmScheme that uses Gateway batching when the seller
-        // supports it and falls back to a standard EIP-3009 `exact` payment
-        // otherwise — no per-request routing logic needed.
-        registerBatchScheme(this.client, {
-            signer: this.account,
-            fallbackScheme: new ExactEvmScheme(this.account),
-        });
-    }
-    async createWordPayment(session) {
-        if (!session.paymentRequired) {
-            throw new Error("Session did not include an x402 one-word payment requirement");
-        }
-        return {
-            paymentPayload: await this.client.createPaymentPayload(session.paymentRequired),
-        };
-    }
-}
 //# sourceMappingURL=payment-engine.js.map

package/dist/payment-engine.js.map

@@ -1 +1 @@
-{"version":3,"file":"payment-engine.js","sourceRoot":"","sources":["../src/payment-engine.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,mBAAmB,EAA4B,MAAM,kCAAkC,CAAC;AACjG,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAUpD;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IACD;IAA7B,YAA6B,UAAU,gBAAgB;QAA1B,YAAO,GAAP,OAAO,CAAmB;IAAG,CAAC;IAE3D,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QACnD,OAAO;YACL,cAAc,EAAE;gBACd,MAAM,EAAE,oBAAoB;gBAC5B,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,YAAY,EAAE,OAAO,CAAC,iBAAiB;gBACvC,YAAY,EAAE,MAAM;aACrB;SACF,CAAC;IACJ,CAAC;CACF;AAID;;;;GAIG;AACH,MAAM,OAAO,0BAA0B;IAIR;IAHZ,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;IAC1B,OAAO,CAAyC;IAEjE,YAA6B,OAA0C;QAA1C,YAAO,GAAP,OAAO,CAAmC;QACrE,IAAI,CAAC,OAAO,GAAG,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC5D,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,oEAAoE;QACpE,mDAAmD;QACnD,mBAAmB,CAAC,IAAI,CAAC,MAAM,EAAE;YAC/B,MAAM,EAAE,IAAI,CAAC,OAAO;YACpB,cAAc,EAAE,IAAI,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC;SACjD,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QACnD,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;QAClF,CAAC;QACD,OAAO;YACL,cAAc,EAAE,MAAM,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,OAAO,CAAC,eAAwB,CAAC;SACzF,CAAC;IACJ,CAAC;CACF"}
+{"version":3,"file":"payment-engine.js","sourceRoot":"","sources":["../src/payment-engine.ts"],"names":[],"mappings":"AAUA;;;GAGG;AACH,MAAM,OAAO,mBAAmB;IACD;IAA7B,YAA6B,UAAU,gBAAgB;QAA1B,YAAO,GAAP,OAAO,CAAmB;IAAG,CAAC;IAE3D,KAAK,CAAC,iBAAiB,CAAC,OAA6B;QACnD,OAAO;YACL,cAAc,EAAE;gBACd,MAAM,EAAE,oBAAoB;gBAC5B,OAAO,EAAE,IAAI,CAAC,OAAO;gBACrB,SAAS,EAAE,OAAO,CAAC,SAAS;gBAC5B,YAAY,EAAE,OAAO,CAAC,iBAAiB;gBACvC,YAAY,EAAE,MAAM;aACrB;SACF,CAAC;IACJ,CAAC;CACF"}

package/dist/payment-engine.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payment-engine.test.d.ts","sourceRoot":"","sources":["../src/payment-engine.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rubicon-caliga/agent-sdk",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Client SDK for autonomous agents consuming per-word article streams via Rubicon x402.",
   "license": "MIT",
   "type": "module",
@@ -24,19 +24,19 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "lint": "tsc -p tsconfig.json --noEmit",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --test dist/**/*.test.js",
-    "prepublishOnly": "pnpm run build"
-  },
   "dependencies": {
-    "@rubicon-caliga/core": "^0.1.0",
+    "@circle-fin/developer-controlled-wallets": "^10.6.0",
     "@circle-fin/x402-batching": "^3.1.2",
     "@x402/core": "^2.15.0",
     "@x402/evm": "^2.15.0",
     "eventsource": "^4.0.0",
-    "viem": "^2.52.2"
+    "viem": "^2.52.2",
+    "@rubicon-caliga/core": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test dist/**/*.test.js"
   }
-}
+}

package/src/agent-client.test.ts

@@ -0,0 +1,118 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { RubiconClient } from "./agent-client.js";
+import type { AgentPaymentEngine } from "./payment-engine.js";
+
+const paymentEngine: AgentPaymentEngine = {
+  async createWordPayment() {
+    return { paymentPayload: { ok: true } };
+  },
+};
+
+test("run receipt preserves Gateway settlement receipt fields", async () => {
+  const fetcher = (async (input: Parameters<typeof fetch>[0]) => {
+    const url = String(input);
+    if (url.endsWith("/v1/sessions")) {
+      return jsonResponse({
+        sessionId: "session_1",
+        state: "active",
+        article: article(),
+        navigation: navigation(),
+        pricePerWordAtomic: "1",
+        maxArticlePriceAtomic: "10",
+        conversationId: "conversation_1",
+        wordPaymentAtomic: "1",
+        gatewayFeeBps: 0,
+        paymentRequired: { scheme: "exact" },
+        expiresAt: "2026-06-18T12:00:00.000Z",
+        wordsPaid: 0,
+        wordsDelivered: 0,
+        paidAtomic: "0",
+      });
+    }
+    if (url.endsWith("/v1/sessions/session_1/payments")) {
+      return jsonResponse({
+        accepted: true,
+        sequence: 0,
+        word: "Rubicon",
+        priceAtomic: "1",
+        wordsPaid: 1,
+        wordsDelivered: 1,
+        paidAtomic: "1",
+        completed: true,
+        transactionHashes: [],
+        settlementIds: ["settlement_1"],
+        payment: {
+          paymentId: "payment_1",
+          sessionId: "session_1",
+          articleId: "article_1",
+          sequence: 0,
+          meteringUnit: "word",
+          amountAtomic: "1",
+          currency: "USDC",
+          network: "eip155:5042002",
+          payTo: "0x3333333333333333333333333333333333333333",
+          transactionHashes: [],
+          settlementIds: ["settlement_1"],
+          buyerWalletAddress: "0x2222222222222222222222222222222222222222",
+          settledAt: "2026-06-18T12:00:00.000Z",
+        },
+      });
+    }
+    throw new Error(`Unexpected fetch: ${url}`);
+  }) as typeof fetch;
+
+  const client = new RubiconClient({
+    baseUrl: "http://rubicon.test",
+    paymentEngine,
+    fetch: fetcher,
+  });
+
+  const receipt = await client.run({
+    articleId: "article_1",
+    maxSpendAtomic: "10",
+  });
+
+  assert.deepEqual(receipt.transactionHashes, []);
+  assert.deepEqual(receipt.settlementIds, ["settlement_1"]);
+  assert.equal(receipt.buyerWalletAddress, "0x2222222222222222222222222222222222222222");
+  assert.equal(receipt.sellerPayTo, "0x3333333333333333333333333333333333333333");
+  assert.equal(receipt.network, "eip155:5042002");
+});
+
+function jsonResponse(body: unknown): Response {
+  return new Response(JSON.stringify(body), {
+    status: 200,
+    headers: { "content-type": "application/json" },
+  });
+}
+
+function article() {
+  return {
+    articleId: "article_1",
+    creatorId: "creator_1",
+    creatorUsername: "creator",
+    title: "Title",
+    author: "Author",
+    state: "published",
+    totalWords: 1,
+    pricePerWordAtomic: "1",
+    maxArticlePriceAtomic: "1",
+    sections: [],
+  };
+}
+
+function navigation() {
+  return {
+    articleId: "article_1",
+    sections: [],
+    sellerAgent: {
+      recommendedSectionId: "intro",
+      alternativeSectionIds: [],
+      rationale: "",
+      safeHints: [],
+      withheld: [],
+    },
+    stopConditions: [],
+  };
+}

package/src/agent-client.ts

@@ -39,6 +39,10 @@ export interface ReadReceipt {
   amountPaidAtomic: `${bigint}`;
   payments: WordPaymentReceipt[];
   transactionHashes: string[];
+  settlementIds: string[];
+  buyerWalletAddress?: `0x${string}`;
+  sellerPayTo?: `0x${string}`;
+  network?: string;
   text: string;
   completed: boolean;
   stopReason: "article_completed" | "stop_condition" | "budget_reached" | "max_words" | "aborted";
@@ -268,6 +272,7 @@ export class RubiconClient {
     let wordsRead = 0;
     let amountPaid = 0n;
     const transactionHashes: string[] = [];
+    const settlementIds: string[] = [];
     const payments: WordPaymentReceipt[] = [];
     let stopReason: ReadReceipt["stopReason"] = "article_completed";
     let completed = false;
@@ -280,6 +285,10 @@ export class RubiconClient {
       amountPaidAtomic: `${amountPaid}`,
       payments: [...payments],
       transactionHashes: [...transactionHashes],
+      settlementIds: [...settlementIds],
+      buyerWalletAddress: [...payments].reverse().find((payment) => payment.buyerWalletAddress)?.buyerWalletAddress,
+      sellerPayTo: [...payments].reverse().find((payment) => payment.payTo)?.payTo,
+      network: [...payments].reverse().find((payment) => payment.network)?.network,
       text,
       completed,
       stopReason,
@@ -326,6 +335,7 @@ export class RubiconClient {
         payments.push(result.payment);
       }
       transactionHashes.push(...(result.transactionHashes ?? (result.transactionHash ? [result.transactionHash] : [])));
+      settlementIds.push(...(result.settlementIds ?? (result.settlementId ? [result.settlementId] : [])));
       text = text ? `${text} ${result.word}` : result.word;
 
       yield {

package/src/circle-agent-wallet.test.ts

@@ -0,0 +1,118 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { serializeTypedData, toEip712Payload } from "./circle-agent-wallet.js";
+
+// The x402 schemes hand the signer viem-style typed data with no EIP712Domain
+// entry; Circle's API needs the complete document. These pin the bridging.
+
+const TRANSFER_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+  ],
+};
+
+const EIP3009_TRANSFER_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" },
+  ],
+};
+
+test("injects EIP712Domain derived from the domain fields present", () => {
+  const payload = toEip712Payload({
+    domain: {
+      name: "USD Coin",
+      version: "2",
+      chainId: 5042002,
+      verifyingContract: "0xabc",
+    },
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: { from: "0x1", to: "0x2", value: "5" },
+  });
+
+  assert.deepEqual(payload.types.EIP712Domain, [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+  ]);
+  // Original typed-data entries are preserved alongside the injected domain.
+  assert.deepEqual(payload.types.TransferWithAuthorization, TRANSFER_TYPES.TransferWithAuthorization);
+  assert.equal(payload.primaryType, "TransferWithAuthorization");
+});
+
+test("only includes domain fields that are actually present", () => {
+  const payload = toEip712Payload({
+    domain: { name: "Test", chainId: 1337 },
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {},
+  });
+
+  assert.deepEqual(payload.types.EIP712Domain, [
+    { name: "name", type: "string" },
+    { name: "chainId", type: "uint256" },
+  ]);
+});
+
+test("does not overwrite an EIP712Domain the caller already supplied", () => {
+  const provided = [{ name: "name", type: "string" }];
+  const payload = toEip712Payload({
+    domain: { name: "Test", chainId: 1337 },
+    types: { ...TRANSFER_TYPES, EIP712Domain: provided },
+    primaryType: "TransferWithAuthorization",
+    message: {},
+  });
+
+  assert.deepEqual(payload.types.EIP712Domain, provided);
+});
+
+test("serializes bigint authorization fields (exact fallback) as decimal strings", () => {
+  // The `exact` scheme hands the signer bigint value/validAfter/validBefore;
+  // plain JSON.stringify would throw, so they must be coerced to strings.
+  const payload = toEip712Payload({
+    domain: { name: "USD Coin", chainId: 5042002 },
+    types: EIP3009_TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: "0x1",
+      to: "0x2",
+      value: 5n,
+      validAfter: 0n,
+      validBefore: 1893456000n,
+      nonce: "0xabc",
+    },
+  });
+
+  const json = serializeTypedData(payload);
+  const parsed = JSON.parse(json);
+  assert.equal(parsed.message.value, "5");
+  assert.equal(parsed.message.validAfter, "0");
+  assert.equal(parsed.message.validBefore, "1893456000");
+});
+
+test("removes message fields that are not declared by the primary type", () => {
+  const payload = toEip712Payload({
+    domain: { name: "USD Coin", chainId: 5042002 },
+    types: TRANSFER_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: {
+      from: "0x1",
+      to: "0x2",
+      value: "5",
+      validAfter: "0",
+      validBefore: "1893456000",
+      nonce: "0xabc",
+      authorization: { unexpected: true },
+    },
+  });
+
+  assert.deepEqual(payload.message, { from: "0x1", to: "0x2", value: "5" });
+});

package/src/circle-agent-wallet.ts

@@ -0,0 +1,210 @@
+import type { StartSessionResponse, StreamPaymentRequest } from "@rubicon-caliga/core";
+import { x402Client } from "@x402/core/client";
+import { registerBatchScheme } from "@circle-fin/x402-batching/client";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import {
+  initiateDeveloperControlledWalletsClient,
+  type CircleDeveloperControlledWalletsClient,
+} from "@circle-fin/developer-controlled-wallets";
+import type { AgentPaymentEngine } from "./payment-engine.js";
+
+export interface CircleAgentWalletEngineOptions {
+  /** Circle API key that controls the Agent Wallet. */
+  apiKey: string;
+  /** Entity secret registered for the Circle developer account. */
+  entitySecret: string;
+  /** The Agent Wallet that holds USDC and signs each one-word payment. */
+  walletId: string;
+  /**
+   * The wallet's on-chain address. Optional — when omitted it is resolved once
+   * from the Circle API via `getWallet` before the first payment is signed.
+   */
+  walletAddress?: `0x${string}`;
+  /** Override the Circle API base URL (e.g. sandbox vs. production). */
+  baseUrl?: string;
+  /** Pre-built Circle client. Mainly an injection point for tests. */
+  client?: CircleDeveloperControlledWalletsClient;
+}
+
+/** The minimal EIP-712 signing request the x402 client hands to a signer. */
+interface TypedDataRequest {
+  domain: Record<string, unknown>;
+  types: Record<string, unknown>;
+  primaryType: string;
+  message: Record<string, unknown>;
+}
+
+/**
+ * viem-shaped signer (`{ address, signTypedData }`) that delegates EIP-712
+ * signing to a Circle Agent Wallet over the API instead of holding a raw
+ * private key. Satisfies both the batch (`BatchEvmSigner`) and exact
+ * (`ClientEvmSigner`) signer contracts used by the Circle x402 schemes.
+ */
+class CircleAgentWalletSigner {
+  // Populated before the first signature — either from options or via getWallet.
+  address: `0x${string}` = "0x0000000000000000000000000000000000000000";
+  private resolved = false;
+  private resolving?: Promise<void>;
+
+  constructor(
+    private readonly client: CircleDeveloperControlledWalletsClient,
+    private readonly walletId: string,
+    address?: `0x${string}`,
+  ) {
+    if (address) {
+      this.address = address;
+      this.resolved = true;
+    }
+  }
+
+  /** Resolves and caches the wallet's on-chain address (idempotent). */
+  async ensureAddress(): Promise<void> {
+    if (this.resolved) return;
+    if (!this.resolving) {
+      this.resolving = this.client.getWallet({ id: this.walletId }).then((res) => {
+        const address = res.data?.wallet.address;
+        if (!address) {
+          throw new Error(`Circle wallet ${this.walletId} did not return an on-chain address`);
+        }
+        this.address = address as `0x${string}`;
+        this.resolved = true;
+      });
+    }
+    return this.resolving;
+  }
+
+  async signTypedData(typed: TypedDataRequest): Promise<`0x${string}`> {
+    // The schemes read `address` synchronously while building the payload, so
+    // make sure it is resolved before we sign.
+    await this.ensureAddress();
+    const res = await this.client.signTypedData({
+      walletId: this.walletId,
+      data: serializeTypedData(toEip712Payload(typed)),
+      memo: "Rubicon one-word payment",
+    });
+    const signature = res.data?.signature;
+    if (!signature) {
+      throw new Error("Circle Agent Wallet did not return a signature for the x402 payment");
+    }
+    return signature as `0x${string}`;
+  }
+}
+
+/**
+ * Circle Agent Wallet engine. Signs the gateway's one-word x402 terms with a
+ * custodial Circle Agent Wallet — the recommended buyer setup — so the agent
+ * never handles a local signing key. Settlement may be batched by Circle, but
+ * each signed payload still corresponds to exactly one word.
+ */
+export class CircleAgentWalletEngine implements AgentPaymentEngine {
+  private readonly x402 = new x402Client();
+  private readonly signer: CircleAgentWalletSigner;
+
+  constructor(options: CircleAgentWalletEngineOptions) {
+    const client =
+      options.client ??
+      initiateDeveloperControlledWalletsClient({
+        apiKey: options.apiKey,
+        entitySecret: options.entitySecret,
+        ...(options.baseUrl ? { baseUrl: options.baseUrl } : {}),
+      });
+    this.signer = new CircleAgentWalletSigner(client, options.walletId, options.walletAddress);
+    // Gasless Gateway batching with an `exact` EIP-3009 fallback. The signer is
+    // a custodial Circle Agent Wallet, not a local private key.
+    registerBatchScheme(this.x402, {
+      signer: this.signer,
+      fallbackScheme: new ExactEvmScheme(this.signer),
+    });
+  }
+
+  async createWordPayment(session: StartSessionResponse): Promise<StreamPaymentRequest> {
+    if (!session.paymentRequired) {
+      throw new Error("Session did not include an x402 one-word payment requirement");
+    }
+    // Resolve the wallet address up front so the synchronous `address` read
+    // inside createPaymentPayload sees a real value.
+    await this.signer.ensureAddress();
+    return {
+      paymentPayload: await this.x402.createPaymentPayload(session.paymentRequired as never),
+    };
+  }
+}
+
+/**
+ * Circle's signTypedData API expects a complete EIP-712 document as a JSON
+ * string. The x402 schemes pass viem-style typed data, which omits the implicit
+ * `EIP712Domain` type, so add it back from whichever domain fields are present.
+ *
+ * Exported for unit testing — application code never calls this directly.
+ */
+/**
+ * Serialize an EIP-712 document to the JSON string Circle's API expects. The
+ * `exact` fallback scheme passes the authorization's `value`/`validAfter`/
+ * `validBefore` as bigints, which `JSON.stringify` cannot encode — emit them as
+ * decimal strings (the EIP-712 JSON convention) instead of throwing.
+ *
+ * Exported for unit testing — application code never calls this directly.
+ */
+export function serializeTypedData(typed: ReturnType<typeof toEip712Payload>): string {
+  return JSON.stringify(typed, (_key, value) =>
+    typeof value === "bigint" ? value.toString() : value,
+  );
+}
+
+export function toEip712Payload(typed: TypedDataRequest) {
+  const domain = typed.domain ?? {};
+  const types = { ...(typed.types as Record<string, unknown>) };
+  if (!types.EIP712Domain) {
+    types.EIP712Domain = eip712DomainFields(domain);
+  }
+  return {
+    domain,
+    types,
+    primaryType: typed.primaryType,
+    message: eip712PrimaryMessage(typed.message, types, typed.primaryType),
+  };
+}
+
+function eip712DomainFields(domain: Record<string, unknown>): Array<{ name: string; type: string }> {
+  const candidates: Array<[string, string]> = [
+    ["name", "string"],
+    ["version", "string"],
+    ["chainId", "uint256"],
+    ["verifyingContract", "address"],
+    ["salt", "bytes32"],
+  ];
+  return candidates
+    .filter(([field]) => domain[field] !== undefined)
+    .map(([name, type]) => ({ name, type }));
+}
+
+function eip712PrimaryMessage(
+  message: Record<string, unknown>,
+  types: Record<string, unknown>,
+  primaryType: string,
+): Record<string, unknown> {
+  const fields = types[primaryType];
+  if (!Array.isArray(fields)) {
+    return message;
+  }
+
+  const allowed = new Set(
+    fields
+      .map((field) => (isEip712Field(field) ? field.name : undefined))
+      .filter((name): name is string => Boolean(name)),
+  );
+  if (allowed.size === 0) {
+    return message;
+  }
+
+  return Object.fromEntries(Object.entries(message).filter(([key]) => allowed.has(key)));
+}
+
+function isEip712Field(field: unknown): field is { name: string; type: string } {
+  return (
+    typeof field === "object" &&
+    field !== null &&
+    typeof (field as { name?: unknown }).name === "string" &&
+    typeof (field as { type?: unknown }).type === "string"
+  );
+}