@haven_ai/signer 0.1.13-alpha.0 → 0.1.15-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,7 @@ var x402ExpectedSchema = v3.z.object({
   amount: v3.z.string().min(1),
   asset: v3.z.string().min(1),
   network: v3.z.string().min(1),
+  expires_at: v3.z.string().min(1).optional(),
   auth: v3.z.object({
     version: v3.z.literal(1),
     message: v3.z.string().min(1),
@@ -62,57 +79,102 @@ var x402ExpectedSchema = v3.z.object({
   })
 });
 var toolSchemas = {
+  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()
   },
   haven_x402_sign_header: {
-    // The parsed HTTP 402 PaymentRequired from the merchant.
-    payment_required: v3.z.unknown(),
+    // The parsed HTTP 402 PaymentRequired from the merchant. Typed as an object
+    // (not z.unknown(), which becomes empty JSON Schema `{}`) so MCP clients
+    // embed it as JSON rather than serialising the object to a string.
+    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, not a top-level field),",
+  "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 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_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_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 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);
@@ -123,7 +185,7 @@ function createToolHandlers(signer, options = {}) {
       return { signature: result.signature, x402_binding: result.x402Binding };
     }),
     haven_x402_sign_header: async (input) => runTool(async () => {
-      const args = parse("haven_x402_sign_header", input);
+      const args = parse("haven_x402_sign_header", coercePaymentRequired(input));
       const result = await signer.buildX402PaymentHeader(
         args.payment_required,
         args.x402_binding
@@ -133,6 +195,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", 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) {
@@ -150,6 +242,16 @@ function createToolHandlers(signer, options = {}) {
 function parse(name, input) {
   return v3.z.object(toolSchemas[name]).parse(input ?? {});
 }
+function coercePaymentRequired(input) {
+  if (!input || typeof input !== "object") return input;
+  const record = input;
+  if (typeof record.payment_required !== "string") return input;
+  try {
+    return { ...record, payment_required: JSON.parse(record.payment_required) };
+  } catch {
+    return input;
+  }
+}
 async function runTool(fn) {
   try {
     return { success: true, data: await fn() };
@@ -173,7 +275,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,
@@ -333,6 +446,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(
@@ -363,9 +482,70 @@ function createEdgeSigner(delegateKey, options = {}) {
       } finally {
         x402Bindings.delete(x402Binding);
       }
+    },
+    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."
+        );
+      }
+      if (expectedSafe && !sameAddress(authorization.to, expectedSafe)) {
+        throw new sdk.HavenSigningError(
+          "Sweep authorization `to` does not match the Safe in the local credential."
+        );
+      }
+      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 { 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;
@@ -407,7 +587,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.");
@@ -419,6 +600,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();
 }
@@ -512,7 +708,7 @@ async function warnIfCredentialFilePermissive(path, log = (message) => process.s
 
 // src/server.ts
 var SIGNER_NAME = "@haven_ai/signer";
-var SIGNER_VERSION = "0.1.13-alpha.0";
+var SIGNER_VERSION = "0.1.15-alpha.0";
 async function resolveSignerRuntime(options = {}) {
   if (options.delegateKey) {
     return {