@haven_ai/signer 0.1.14-alpha.0 → 0.1.16-alpha.0

package/dist/cli.cjs

@@ -46,6 +46,22 @@ function stableStringify(value) {
   const object = value;
   return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
 }
+var sweepAuthorizationSchema = v3.z.object({
+  from: v3.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "from must be a 0x address"),
+  to: v3.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "to must be a 0x address"),
+  value: v3.z.string().regex(/^[0-9]+$/, "value must be a decimal atomic amount"),
+  validAfter: v3.z.string().regex(/^[0-9]+$/, "validAfter must be a decimal unix time"),
+  validBefore: v3.z.string().regex(/^[0-9]+$/, "validBefore must be a decimal unix time"),
+  nonce: v3.z.string().regex(/^0x[0-9a-fA-F]{64}$/, "nonce must be a 0x-prefixed 32-byte hex string"),
+  token: v3.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "token must be a 0x address"),
+  chainId: v3.z.number().int().positive()
+});
+var sweepExpectedAuthSchema = v3.z.object({
+  version: v3.z.literal(1),
+  message: v3.z.string().min(1),
+  signature: v3.z.string().regex(/^0x[0-9a-fA-F]+$/, "signature must be a 0x-prefixed hex string"),
+  signer: v3.z.string().regex(/^0x[0-9a-fA-F]{40}$/, "signer must be a 0x address")
+});
 var x402ExpectedSchema = v3.z.object({
   payment_id: v3.z.string().min(1),
   payload_hash: v3.z.string().regex(/^0x[0-9a-fA-F]+$/, "payload_hash must be a 0x-prefixed hex string"),
@@ -54,6 +70,11 @@ var x402ExpectedSchema = v3.z.object({
   amount: v3.z.string().min(1),
   asset: v3.z.string().min(1),
   network: v3.z.string().min(1),
+  // Required: expires_at is folded into the Haven-signed binding message, so the
+  // signer must receive the exact same value to reconstruct a matching message.
+  // Omitting it used to fail downstream with a cryptic "authentication message is
+  // invalid" — making it required surfaces a clear INVALID_INPUT at the boundary.
+  expires_at: v3.z.string().min(1),
   auth: v3.z.object({
     version: v3.z.literal(1),
     message: v3.z.string().min(1),
@@ -62,11 +83,18 @@ var x402ExpectedSchema = v3.z.object({
   })
 });
 var toolSchemas = {
-  haven_sweep_delegate: {},
+  haven_sign_sweep_delegate: {
+    // The authorization fields prepared by Haven's POST /sweep/prepare. Passed
+    // through verbatim from the hosted haven_sweep_delegate tool — the signer
+    // re-derives the binding message from these exact values.
+    authorization: sweepAuthorizationSchema,
+    // Haven's signature over the authorization context (the binding).
+    expected_auth: sweepExpectedAuthSchema
+  },
   haven_sign: {
-    // The unsigned hash from haven_pay / haven_x402_authorize (payload_hash).
+    // The unsigned hash from haven_pay / haven_pay_x402_quote (payload_hash).
     payload_hash: v3.z.string().regex(/^0x[0-9a-fA-F]+$/, "payload_hash must be a 0x-prefixed hex string"),
-    // Pass x402.expected from hosted haven_x402_authorize when this hash funds
+    // Pass x402.expected from hosted haven_pay_x402_quote when this hash funds
     // a standard x402 merchant retry. The signer records it locally and returns
     // an opaque x402_binding for the later header-signing step.
     x402_expected: x402ExpectedSchema.optional()
@@ -78,67 +106,79 @@ var toolSchemas = {
     payment_required: v3.z.record(v3.z.string(), v3.z.unknown()),
     // Opaque binding returned by haven_sign when x402_expected was supplied.
     x402_binding: v3.z.string().min(1)
+  },
+  haven_sign_x402: {
+    // One-shot x402 signing: funding hash + merchant header in one local call.
+    payload_hash: v3.z.string().regex(/^0x[0-9a-fA-F]+$/, "payload_hash must be a 0x-prefixed hex string"),
+    x402_expected: x402ExpectedSchema,
+    payment_required: v3.z.record(v3.z.string(), v3.z.unknown())
   }
 };
 var SIGN_DESCRIPTION = [
   "Sign an unsigned Haven payment hash with the local delegate key. The delegate key never leaves",
   "this process. Pass the payload_hash returned by haven_pay or haven_pay_x402_quote.",
   "For x402, also pass x402_expected from haven_pay_x402_quote; the signer records it locally",
-  "and returns { signature, x402_binding }. Hand signature to haven_submit, then pass x402_binding",
-  "to haven_x402_sign_header. For plain SafeTransfer payments, just pass payload_hash and",
-  "relay the returned signature via haven_submit."
+  "and returns { signature, x402_binding }. x402_expected includes expires_at; sign before that",
+  "window closes. Next: call mcp__haven__haven_submit with signature, then pass x402_binding",
+  "to mcp__haven-signer__haven_x402_sign_header. For plain SafeTransfer payments, just pass payload_hash and",
+  "relay the returned signature via mcp__haven__haven_submit."
 ].join(" ");
 var X402_SIGN_HEADER_DESCRIPTION = [
   "Build and sign the EIP-3009 X-PAYMENT header for the merchant leg of an x402 payment.",
   "The delegate key stays local \u2014 only the signed header crosses any boundary.",
   "Pass the payment_required from the original merchant 402 response and the x402_binding",
   "returned by haven_sign. The signer validates the merchant, amount, resource, asset, and",
-  "network against the recorded funding context before signing, and rejects mismatches.",
+  "network against the recorded funding context before signing, checks expires_at when present,",
+  "and rejects mismatches or expired payment windows.",
   "Returns { payment_header, accepted }. Set X-PAYMENT: <payment_header> on your retry to the",
   "merchant. Only call after haven_submit has confirmed the funding step (nextAction=none or",
-  "the funding tx has a confirmed status)."
+  "the funding tx has a confirmed status). Next for paid MCP tools: call mcp__haven__haven_complete_mcp_tool."
+].join(" ");
+var SIGN_X402_DESCRIPTION = [
+  "One-shot x402 signing for the fast 3-call flow: sign the funding hash AND build the EIP-3009",
+  "X-PAYMENT header in a single local call (equivalent to haven_sign followed by",
+  "haven_x402_sign_header). The delegate key never leaves this process. From the haven_pay_mcp_tool",
+  "result pass payload_hash, x402_expected (the nested x402.expected object \u2014 passing the whole x402",
+  "object is also accepted and unwrapped for you), and payment_required (verbatim). Returns",
+  "{ signature, x402_binding, payment_header, accepted }; hand signature + payment_header to",
+  "mcp__haven__haven_settle_mcp_tool to fund and settle in one hosted call. The header is built now (before",
+  "funding confirms), so its short validity window starts here \u2014 call mcp__haven__haven_settle_mcp_tool promptly,",
+  "and re-run mcp__haven__haven_pay_mcp_tool with the same idempotency_key if a tool returns PAYMENT_WINDOW_EXPIRED.",
+  "Next: call mcp__haven__haven_settle_mcp_tool."
 ].join(" ");
-var SWEEP_DELEGATE_DESCRIPTION = [
-  "Sweep stranded USDC and/or ETH from the delegate wallet back to the originating Safe.",
-  "Use when a payment failed or expired after funding, leaving funds on the delegate EOA.",
-  "Signs ERC-20 transfer and native ETH transfer transactions locally with the delegate key.",
-  "Only supported on Base (chainId 8453). Returns tx hashes and recovered amounts.",
-  "Returns an empty transfers list when nothing is stranded."
+var SIGN_SWEEP_DELEGATE_DESCRIPTION = [
+  "Sign a Haven-prepared gasless USDC sweep that recovers stranded funds from the delegate",
+  "wallet back to your Haven wallet. The delegate key never leaves this process and this tool",
+  "never broadcasts \u2014 it returns only an EIP-3009 signature that Haven's relayer submits and",
+  "pays gas for. Pass the authorization and expected_auth returned by the hosted",
+  "haven_sweep_delegate tool. The signer verifies Haven authored the authorization and that it",
+  "pays out to your own Safe before signing, then returns { signature } to hand back to",
+  "mcp__haven__haven_sweep_delegate to complete recovery."
 ].join(" ");
 var toolDescriptions = {
-  haven_sweep_delegate: SWEEP_DELEGATE_DESCRIPTION,
   haven_sign: SIGN_DESCRIPTION,
-  haven_x402_sign_header: X402_SIGN_HEADER_DESCRIPTION
+  haven_x402_sign_header: X402_SIGN_HEADER_DESCRIPTION,
+  haven_sign_x402: SIGN_X402_DESCRIPTION,
+  haven_sign_sweep_delegate: SIGN_SWEEP_DELEGATE_DESCRIPTION
 };
+function toExpectedX402(raw) {
+  return {
+    paymentId: raw.payment_id,
+    payloadHash: raw.payload_hash,
+    resourceUrl: raw.resource_url,
+    merchantTo: raw.merchant_to,
+    amount: raw.amount,
+    asset: raw.asset,
+    network: raw.network,
+    expiresAt: raw.expires_at,
+    auth: raw.auth
+  };
+}
 function createToolHandlers(signer, options = {}) {
   return {
-    haven_sweep_delegate: async () => runTool(async () => {
-      const safeAddress = options.audit?.safeAddress;
-      const chainId = options.audit?.chainId;
-      if (!safeAddress) {
-        throw new Error(
-          "Sweep requires a Safe address \u2014 ensure credentials include safe_address."
-        );
-      }
-      if (typeof chainId !== "number") {
-        throw new Error(
-          "Sweep requires a chainId \u2014 ensure credentials include chain_id."
-        );
-      }
-      return signer.sweepDelegate({ safeAddress, chainId });
-    }),
     haven_sign: async (input) => runTool(async () => {
-      const args = parse("haven_sign", input);
-      const x402Expected = args.x402_expected ? {
-        paymentId: args.x402_expected.payment_id,
-        payloadHash: args.x402_expected.payload_hash,
-        resourceUrl: args.x402_expected.resource_url,
-        merchantTo: args.x402_expected.merchant_to,
-        amount: args.x402_expected.amount,
-        asset: args.x402_expected.asset,
-        network: args.x402_expected.network,
-        auth: args.x402_expected.auth
-      } : null;
+      const args = parse("haven_sign", coerceX402Expected(input));
+      const x402Expected = args.x402_expected ? toExpectedX402(args.x402_expected) : null;
       const result = x402Expected ? signer.signX402FundingHash(args.payload_hash, x402Expected) : null;
       if (!result) {
         const signature = signer.signPaymentHash(args.payload_hash);
@@ -159,6 +199,36 @@ function createToolHandlers(signer, options = {}) {
         hashPayloadForAudit(args.payment_required)
       );
       return { payment_header: result.paymentHeader, accepted: result.accepted };
+    }),
+    haven_sign_x402: async (input) => runTool(async () => {
+      const args = parse("haven_sign_x402", coerceX402Expected(coercePaymentRequired(input)));
+      const funding = signer.signX402FundingHash(args.payload_hash, toExpectedX402(args.x402_expected));
+      const header = await signer.buildX402PaymentHeader(
+        args.payment_required,
+        funding.x402Binding
+      );
+      await auditSigning("haven_sign_x402", args.payload_hash);
+      await auditSigning("haven_sign_x402", hashPayloadForAudit(args.payment_required));
+      return {
+        signature: funding.signature,
+        x402_binding: funding.x402Binding,
+        payment_header: header.paymentHeader,
+        accepted: header.accepted
+      };
+    }),
+    haven_sign_sweep_delegate: async (input) => runTool(async () => {
+      const args = parse("haven_sign_sweep_delegate", input);
+      const result = await signer.signSweepAuthorization({
+        authorization: args.authorization,
+        expectedAuth: args.expected_auth,
+        // Cross-check `to` against the Safe in the local credential when present.
+        expectedSafe: options.audit?.safeAddress
+      });
+      await auditSigning(
+        "haven_sign_sweep_delegate",
+        hashPayloadForAudit(args.authorization)
+      );
+      return { signature: result.signature };
     })
   };
   async function auditSigning(tool, payloadHash) {
@@ -176,6 +246,25 @@ function createToolHandlers(signer, options = {}) {
 function parse(name, input) {
   return v3.z.object(toolSchemas[name]).parse(input ?? {});
 }
+function coerceX402Expected(input) {
+  if (!input || typeof input !== "object") return input;
+  const record = input;
+  let value = record.x402_expected;
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      return input;
+    }
+  }
+  if (!value || typeof value !== "object") return input;
+  const obj = value;
+  if (obj.auth === void 0 && obj.expected && typeof obj.expected === "object") {
+    return { ...record, x402_expected: obj.expected };
+  }
+  if (value !== record.x402_expected) return { ...record, x402_expected: value };
+  return input;
+}
 function coercePaymentRequired(input) {
   if (!input || typeof input !== "object") return input;
   const record = input;
@@ -209,7 +298,18 @@ function normalizeError(err) {
     return { success: false, code: err.code, message: err.message, statusCode: err.statusCode };
   }
   if (err instanceof sdk.HavenError) {
-    return { success: false, code: err.code, message: err.message, statusCode: err.statusCode };
+    return {
+      success: false,
+      code: err.code,
+      message: err.message,
+      statusCode: err.statusCode,
+      paymentId: err.paymentId,
+      ...err.code === sdk.AgentPaymentFailureCode.PaymentWindowExpired ? {
+        next_action: sdk.AgentPaymentNextAction.PaymentWindowExpired,
+        retry_with_new_quote: true,
+        suggested_tool: "haven_pay_mcp_tool"
+      } : {}
+    };
   }
   return {
     success: false,
@@ -331,42 +431,6 @@ async function writeAckFile(path$1, hash) {
     "utf8"
   );
 }
-var BASE_CHAIN_ID = 8453;
-var BASE_RPC_URL = "https://mainnet.base.org";
-var BASE_USDC_ADDRESS = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var BASE_EXPLORER_TX = "https://basescan.org/tx";
-var BASE_CHAIN = {
-  id: BASE_CHAIN_ID,
-  name: "Base",
-  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
-  rpcUrls: { default: { http: [BASE_RPC_URL] } }
-};
-var ERC20_ABI = [
-  {
-    name: "balanceOf",
-    type: "function",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    name: "transfer",
-    type: "function",
-    inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: [{ name: "", type: "bool" }],
-    stateMutability: "nonpayable"
-  }
-];
-function formatTokenAmount(atomic, decimals) {
-  const divisor = 10n ** BigInt(decimals);
-  const whole = atomic / divisor;
-  const frac = atomic % divisor;
-  if (frac === 0n) return whole.toString();
-  return `${whole}.${frac.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
-}
 function createEdgeSigner(delegateKey, options = {}) {
   let delegateAddress;
   try {
@@ -405,6 +469,12 @@ function createEdgeSigner(delegateKey, options = {}) {
           "x402 funding binding is required before signing a merchant header. Sign the hosted funding hash with x402_expected first."
         );
       }
+      try {
+        assertX402PaymentWindowOpen(expected);
+      } catch (err) {
+        x402Bindings.delete(x402Binding);
+        throw err;
+      }
       const option = sdk.selectStandardPaymentOption(paymentRequired.accepts);
       if (!option) {
         throw new sdk.HavenApiError(
@@ -436,64 +506,69 @@ function createEdgeSigner(delegateKey, options = {}) {
         x402Bindings.delete(x402Binding);
       }
     },
-    async sweepDelegate({ safeAddress, chainId }) {
-      if (chainId !== BASE_CHAIN_ID) {
-        throw new sdk.HavenApiError(
-          `Sweep is only supported on Base (chainId ${BASE_CHAIN_ID}). Got chainId ${chainId}.`,
-          422
+    async signSweepAuthorization({
+      authorization,
+      expectedAuth,
+      expectedSafe
+    }) {
+      assertSweepBinding(authorization, expectedAuth, options.x402BindingSigner);
+      if (!sameAddress(authorization.from, delegateAddress)) {
+        throw new sdk.HavenSigningError(
+          "Sweep authorization `from` does not match this delegate address."
         );
       }
-      const account = accounts.privateKeyToAccount(delegateKey);
-      const publicClient = viem.createPublicClient({ chain: BASE_CHAIN, transport: viem.http(BASE_RPC_URL) });
-      const walletClient = viem.createWalletClient({ account, chain: BASE_CHAIN, transport: viem.http(BASE_RPC_URL) });
-      const transfers = [];
-      const usdcBalance = await publicClient.readContract({
-        address: BASE_USDC_ADDRESS,
-        abi: ERC20_ABI,
-        functionName: "balanceOf",
-        args: [account.address]
-      });
-      if (usdcBalance > 0n) {
-        const hash = await walletClient.writeContract({
-          address: BASE_USDC_ADDRESS,
-          abi: ERC20_ABI,
-          functionName: "transfer",
-          args: [safeAddress, usdcBalance]
-        });
-        await publicClient.waitForTransactionReceipt({ hash });
-        transfers.push({
-          asset: "USDC",
-          amount: formatTokenAmount(usdcBalance, 6),
-          amountAtomic: usdcBalance.toString(),
-          txHash: hash,
-          explorerUrl: `${BASE_EXPLORER_TX}/${hash}`
-        });
+      if (expectedSafe && !sameAddress(authorization.to, expectedSafe)) {
+        throw new sdk.HavenSigningError(
+          "Sweep authorization `to` does not match the Safe in the local credential."
+        );
       }
-      const ethBalance = await publicClient.getBalance({ address: account.address });
-      if (ethBalance > 0n) {
-        const gasPrice = await publicClient.getGasPrice() ?? 1000000n;
-        const gasLimit = 21000n;
-        const gasCost = gasPrice * gasLimit;
-        const toSend = ethBalance > gasCost ? ethBalance - gasCost : 0n;
-        if (toSend > 0n) {
-          const hash = await walletClient.sendTransaction({
-            to: safeAddress,
-            value: toSend
-          });
-          await publicClient.waitForTransactionReceipt({ hash });
-          transfers.push({
-            asset: "ETH",
-            amount: formatTokenAmount(toSend, 18),
-            amountAtomic: toSend.toString(),
-            txHash: hash,
-            explorerUrl: `${BASE_EXPLORER_TX}/${hash}`
-          });
+      const typedData = sdk.buildSweepTypedData(authorization);
+      const viemTypedData = {
+        domain: {
+          ...typedData.domain,
+          verifyingContract: typedData.domain.verifyingContract
+        },
+        types: typedData.types,
+        primaryType: typedData.primaryType,
+        message: {
+          ...typedData.message,
+          from: typedData.message.from,
+          to: typedData.message.to,
+          nonce: typedData.message.nonce
         }
+      };
+      const account = accounts.privateKeyToAccount(delegateKey);
+      const signature = await account.signTypedData(viemTypedData);
+      const recovered = await viem.recoverTypedDataAddress({ ...viemTypedData, signature });
+      if (!sameAddress(recovered, delegateAddress)) {
+        throw new sdk.HavenSigningError(
+          "Local sweep signature verification failed \u2014 recovered address does not match the delegate key."
+        );
       }
-      return { fromAddress: account.address, toAddress: safeAddress, chainId, transfers };
+      return { signature };
     }
   };
 }
+function assertSweepBinding(authorization, expectedAuth, trustedSigner) {
+  if (!expectedAuth || typeof expectedAuth !== "object") {
+    throw new sdk.HavenSigningError("Sweep authorization binding is required before signing.");
+  }
+  if (!trustedSigner) {
+    throw new sdk.HavenSigningError(
+      "Sweep binding verifier is not configured. Set HAVEN_X402_BINDING_SIGNER before signing sweep authorizations."
+    );
+  }
+  const message = sdk.buildSweepAuthorizationMessage(authorization);
+  if (expectedAuth.version !== 1 || expectedAuth.message !== message) {
+    throw new sdk.HavenSigningError("Sweep authorization binding does not match the authorization being signed.");
+  }
+  if (!sameAddress(expectedAuth.signer, trustedSigner)) {
+    throw new sdk.HavenSigningError("Sweep authorization binding was not signed by the configured Haven signer.");
+  }
+  if (!sdk.verifySignature(viem.hashMessage(message), expectedAuth.signature, trustedSigner)) {
+    throw new sdk.HavenSigningError("Sweep authorization binding signature could not be verified.");
+  }
+}
 function assertX402MatchesExpected(paymentRequired, option, expected) {
   assertExpectedShape(expected);
   const headerResource = option.resource ?? paymentRequired.resource.url;
@@ -535,7 +610,8 @@ function assertExpectedBinding(payloadHash, expected, trustedSigner) {
     merchantTo: expected.merchantTo,
     amount: expected.amount,
     asset: expected.asset,
-    network: expected.network
+    network: expected.network,
+    expiresAt: expected.expiresAt
   });
   if (expected.auth?.version !== 1 || expected.auth.message !== message) {
     throw new sdk.HavenSigningError("x402 expected context authentication message is invalid.");
@@ -547,6 +623,21 @@ function assertExpectedBinding(payloadHash, expected, trustedSigner) {
     throw new sdk.HavenSigningError("x402 expected context signature could not be verified.");
   }
 }
+function assertX402PaymentWindowOpen(expected) {
+  if (!expected.expiresAt) return;
+  const expiresAtMs = Date.parse(expected.expiresAt);
+  if (Number.isNaN(expiresAtMs)) {
+    throw new sdk.HavenSigningError("x402 expected context expiresAt is not a valid ISO timestamp.");
+  }
+  if (expiresAtMs <= Date.now()) {
+    throw new sdk.HavenError(
+      "The x402 payment window expired before the merchant header could be signed. Re-quote with haven_pay_mcp_tool using the same idempotency_key before trying again.",
+      sdk.AgentPaymentFailureCode.PaymentWindowExpired,
+      410,
+      expected.paymentId
+    );
+  }
+}
 function sameAddress(a, b) {
   return a.toLowerCase() === b.toLowerCase();
 }
@@ -640,7 +731,7 @@ async function warnIfCredentialFilePermissive(path, log = (message) => process.s
 
 // src/server.ts
 var SIGNER_NAME = "@haven_ai/signer";
-var SIGNER_VERSION = "0.1.14-alpha.0";
+var SIGNER_VERSION = "0.1.16-alpha.0";
 async function resolveSignerRuntime(options = {}) {
   if (options.delegateKey) {
     return {