@relai-fi/x402 0.6.8 → 0.6.10

package/dist/index.js

@@ -4454,19 +4454,26 @@ function submitRelayFeedback(config2) {
 
 // src/solana-payment-codes.ts
 var DEFAULT_FACILITATOR = "https://relai.fi/facilitator";
-function generateCode() {
+function generateCode(network, claimLink = false) {
   const chars = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-  const bytes = new Uint8Array(8);
+  const randomLength = claimLink ? 6 : 7;
+  const bytes = new Uint8Array(randomLength);
   if (typeof globalThis !== "undefined" && globalThis.crypto?.getRandomValues) {
     globalThis.crypto.getRandomValues(bytes);
   } else {
     const { randomBytes } = __require("crypto");
-    randomBytes(8).copy(Buffer.from(bytes.buffer));
+    randomBytes(randomLength).copy(Buffer.from(bytes.buffer));
   }
-  let code = "";
-  for (let i = 0; i < 8; i++) code += chars[bytes[i] % chars.length];
+  let code = network === "solana-devnet" ? "D" : "S";
+  if (claimLink) code += "Z";
+  for (let i = 0; i < bytes.length; i++) code += chars[bytes[i] % chars.length];
   return code;
 }
+function buildClaimUrl(facilitatorUrl, claimToken) {
+  if (!claimToken) return null;
+  const origin = new URL(facilitatorUrl).origin;
+  return new URL(`/claim/${claimToken}`, origin).toString();
+}
 async function anchorDisc(name) {
   const preimage = new TextEncoder().encode(`global:${name}`);
   if (typeof globalThis !== "undefined" && globalThis.crypto?.subtle) {
@@ -4476,14 +4483,21 @@ async function anchorDisc(name) {
   const { createHash } = __require("crypto");
   return new Uint8Array(createHash("sha256").update(preimage).digest()).slice(0, 8);
 }
+function writeBigInt64LE(target, value, offset) {
+  let remaining = BigInt.asUintN(64, value);
+  for (let index = 0; index < 8; index += 1) {
+    target[offset + index] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+}
 async function buildInstructionData(name, codeBytes, extra) {
   const disc = await anchorDisc(name);
   if (name === "create_vault" && extra) {
     const buf2 = Buffer.alloc(32);
     Buffer.from(disc).copy(buf2, 0);
     Buffer.from(codeBytes).copy(buf2, 8);
-    buf2.writeBigUInt64LE(extra.amount, 16);
-    buf2.writeBigInt64LE(extra.validUntil, 24);
+    writeBigInt64LE(buf2, extra.amount, 16);
+    writeBigInt64LE(buf2, extra.validUntil, 24);
     return buf2;
   }
   const buf = Buffer.alloc(16);
@@ -4493,7 +4507,7 @@ async function buildInstructionData(name, codeBytes, extra) {
 }
 async function generateSolanaPaymentCode(config2, wallet, params) {
   const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR;
-  const { solanaRpcUrl, ttlSeconds = 86400 } = params;
+  const { solanaRpcUrl, ttlSeconds = 86400, claimLink = false } = params;
   const amount2 = BigInt(params.amount);
   if (amount2 <= 0n) throw new Error("amount must be positive");
   if (!wallet.publicKey) throw new Error("Solana wallet not connected");
@@ -4504,7 +4518,7 @@ async function generateSolanaPaymentCode(config2, wallet, params) {
   const relayerAddr = relayerInfo.address;
   const programId = relayerInfo.programId;
   const usdcMint = relayerInfo.networks?.[network]?.usdc ?? (network === "solana-devnet" ? "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU" : "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
-  const code = generateCode();
+  const code = generateCode(network, claimLink);
   const codeBytes = new TextEncoder().encode(code);
   const {
     Connection: Connection2,
@@ -4536,6 +4550,8 @@ async function generateSolanaPaymentCode(config2, wallet, params) {
   const createVaultIx = new TransactionInstruction({
     programId: programPK,
     keys: [
+      { pubkey: relayerPK, isSigner: true, isWritable: true },
+      // caller / fee payer
       { pubkey: buyerPK, isSigner: true, isWritable: true },
       // buyer
       { pubkey: vaultPda, isSigner: false, isWritable: true },
@@ -4567,7 +4583,9 @@ async function generateSolanaPaymentCode(config2, wallet, params) {
     code,
     amount: amount2.toString(),
     network,
-    ttlSeconds
+    ttlSeconds,
+    claimLink,
+    ...params.description ? { description: params.description } : {}
   };
   const res = await fetch(`${facilitatorUrl}/solana-payment-codes`, {
     method: "POST",
@@ -4578,7 +4596,129 @@ async function generateSolanaPaymentCode(config2, wallet, params) {
     const err = await res.json().catch(() => ({}));
     throw new Error(err.error ?? `generateSolanaPaymentCode failed: ${res.status}`);
   }
-  return res.json();
+  const payload = await res.json();
+  if (payload.claimLink === true) {
+    const claimToken = typeof payload.claimToken === "string" ? payload.claimToken : null;
+    const sanitized = { ...payload };
+    delete sanitized.claimToken;
+    delete sanitized.id;
+    delete sanitized.code;
+    return {
+      ...sanitized,
+      claimLink: true,
+      claimUrl: buildClaimUrl(facilitatorUrl, claimToken)
+    };
+  }
+  return payload;
+}
+async function generateSolanaPaymentCodesBatch(config2, wallet, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR;
+  const items = Array.isArray(params.items) ? params.items : [];
+  if (items.length === 0) throw new Error("items must not be empty");
+  if (items.length > 10) throw new Error("Maximum 10 Solana batch items are supported per transaction");
+  if (!wallet.publicKey) throw new Error("Solana wallet not connected");
+  const infoRes = await fetch(`${facilitatorUrl}/solana-payment-codes/relayer-info`);
+  if (!infoRes.ok) throw new Error("Failed to fetch Solana relayer info");
+  const relayerInfo = await infoRes.json();
+  const network = params.network ?? relayerInfo.defaultNetwork ?? "solana";
+  const relayerAddr = relayerInfo.address;
+  const programId = relayerInfo.programId;
+  const usdcMint = relayerInfo.networks?.[network]?.usdc ?? (network === "solana-devnet" ? "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU" : "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+  const {
+    Connection: Connection2,
+    PublicKey: PublicKey2,
+    TransactionMessage: TransactionMessage2,
+    VersionedTransaction: VersionedTransaction2,
+    TransactionInstruction
+  } = await import("@solana/web3.js");
+  const {
+    getAssociatedTokenAddressSync,
+    TOKEN_PROGRAM_ID: TOKEN_PROGRAM_ID2,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  } = await import("@solana/spl-token");
+  const rpcUrl = params.solanaRpcUrl ?? (network === "solana-devnet" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com");
+  const connection = new Connection2(rpcUrl, "confirmed");
+  const programPK = new PublicKey2(programId);
+  const mintPK = new PublicKey2(usdcMint);
+  const buyerPK = new PublicKey2(wallet.publicKey.toString());
+  const relayerPK = new PublicKey2(relayerAddr);
+  const buyerAta = getAssociatedTokenAddressSync(mintPK, buyerPK, false, TOKEN_PROGRAM_ID2);
+  const systemProgram = new PublicKey2("11111111111111111111111111111111");
+  const usedCodes = /* @__PURE__ */ new Set();
+  const preparedItems = [];
+  const instructions = [];
+  let totalAmount = 0n;
+  for (const item of items) {
+    const amount2 = BigInt(item.amount);
+    if (amount2 <= 0n) throw new Error("Each batch item amount must be positive");
+    const ttlSeconds = Math.min(Math.max(Math.round(Number(item.ttlSeconds ?? 86400)), 60), 604800);
+    const validUntil = BigInt(Math.floor(Date.now() / 1e3) + ttlSeconds);
+    let code = generateCode(network, false);
+    while (usedCodes.has(code)) code = generateCode(network, false);
+    usedCodes.add(code);
+    const codeBytes = new TextEncoder().encode(code);
+    const [vaultPda] = PublicKey2.findProgramAddressSync(
+      [Buffer.from("vault"), Buffer.from(codeBytes)],
+      programPK
+    );
+    const vaultAta = getAssociatedTokenAddressSync(mintPK, vaultPda, true, TOKEN_PROGRAM_ID2);
+    const ixData = await buildInstructionData("create_vault", codeBytes, { amount: amount2, validUntil });
+    instructions.push(new TransactionInstruction({
+      programId: programPK,
+      keys: [
+        { pubkey: relayerPK, isSigner: true, isWritable: true },
+        { pubkey: buyerPK, isSigner: true, isWritable: true },
+        { pubkey: vaultPda, isSigner: false, isWritable: true },
+        { pubkey: vaultAta, isSigner: false, isWritable: true },
+        { pubkey: buyerAta, isSigner: false, isWritable: true },
+        { pubkey: mintPK, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID2, isSigner: false, isWritable: false },
+        { pubkey: ASSOCIATED_TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: systemProgram, isSigner: false, isWritable: false }
+      ],
+      data: ixData
+    }));
+    preparedItems.push({
+      code,
+      amount: amount2,
+      ttlSeconds,
+      description: item.description,
+      validUntil
+    });
+    totalAmount += amount2;
+  }
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const message = new TransactionMessage2({
+    payerKey: relayerPK,
+    recentBlockhash: blockhash,
+    instructions
+  }).compileToV0Message();
+  const tx = new VersionedTransaction2(message);
+  const signed = await wallet.signTransaction(tx);
+  const serialized = Buffer.from(signed.serialize()).toString("base64");
+  const res = await fetch(`${facilitatorUrl}/solana-payment-codes/batch`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      transaction: serialized,
+      network,
+      items: preparedItems.map((item) => ({
+        code: item.code,
+        amount: item.amount.toString(),
+        ttlSeconds: item.ttlSeconds,
+        ...item.description ? { description: item.description } : {}
+      }))
+    })
+  });
+  if (!res.ok) {
+    const err = await res.json().catch(() => ({}));
+    throw new Error(err.error ?? `generateSolanaPaymentCodesBatch failed: ${res.status}`);
+  }
+  const payload = await res.json();
+  return {
+    ...payload,
+    totalAmount: typeof payload.totalAmount === "string" ? payload.totalAmount : totalAmount.toString()
+  };
 }
 async function getSolanaPaymentCode(config2, code) {
   const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR;
@@ -4648,6 +4788,8 @@ async function cancelSolanaPaymentCode(config2, code, wallet, options = {}) {
   const cancelIx = new TransactionInstruction({
     programId: programPK,
     keys: [
+      { pubkey: relayerPK, isSigner: true, isWritable: true },
+      // caller / fee payer
       { pubkey: buyerPK, isSigner: true, isWritable: true },
       // buyer (must sign)
       { pubkey: vaultPda, isSigner: false, isWritable: true },
@@ -4737,6 +4879,7 @@ function createPrivateKeySigner(privateKey) {
   };
 }
 var DEFAULT_FACILITATOR2 = "https://relai.fi/facilitator";
+var AUTHORIZATION_WINDOW_SECONDS = 3600;
 function randomBytes32() {
   const bytes = new Uint8Array(32);
   if (typeof globalThis.crypto !== "undefined") {
@@ -4754,6 +4897,14 @@ async function fetchToAddress(facilitatorUrl, network) {
   if (!data.toAddress) throw new Error("Facilitator returned no toAddress");
   return data.toAddress;
 }
+async function fetchEscrowAddress(facilitatorUrl, network) {
+  const res = await fetch(`${facilitatorUrl}/payment-codes/relayer-address`);
+  if (!res.ok) throw new Error("Failed to fetch escrow address from facilitator");
+  const data = await res.json();
+  const escrowAddress = data.escrowAddresses?.[network];
+  if (!escrowAddress) throw new Error(`Facilitator returned no escrow address for ${network}`);
+  return escrowAddress;
+}
 async function signEip3009(signer, net, from4, toAddress, value, validAfter, validBefore, nonce, usdcOverride) {
   const domain2 = {
     name: net.domainName,
@@ -4828,8 +4979,7 @@ async function generatePaymentCodesBatch(config2, params) {
     codes,
     payee,
     usdcContract,
-    network = "base-sepolia",
-    authToken
+    network = "base-sepolia"
   } = params;
   const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR2;
   const net = NETWORK_CONFIGS[network];
@@ -4839,44 +4989,76 @@ async function generatePaymentCodesBatch(config2, params) {
   const usdc = usdcContract ?? net.usdc;
   const now = Math.floor(Date.now() / 1e3);
   const toAddress = await fetchToAddress(facilitatorUrl, network);
-  const signedCodes = await Promise.all(
-    codes.map(async (item) => {
+  const escrowAddress = await fetchEscrowAddress(facilitatorUrl, network);
+  const results = [];
+  const failed = [];
+  for (let index = 0; index < codes.length; index += 1) {
+    const item = codes[index];
+    try {
       const validBefore = now + (item.ttl ?? 86400);
+      const authorizationValidBefore = Math.min(validBefore, now + AUTHORIZATION_WINDOW_SECONDS);
       const nonce = randomBytes32();
       const value = BigInt(item.value).toString();
+      const authorization = {
+        from: from4,
+        to: escrowAddress,
+        value,
+        validAfter: 0,
+        validBefore: authorizationValidBefore,
+        nonce
+      };
       const signature2 = await signEip3009(
         signer,
         net,
         from4,
-        toAddress,
+        escrowAddress,
         value,
-        0,
-        validBefore,
-        nonce,
+        authorization.validAfter,
+        authorization.validBefore,
+        authorization.nonce,
         usdc
       );
-      return { value, validAfter: 0, validBefore, nonce, signature: signature2 };
-    })
-  );
-  const res = await fetch(`${facilitatorUrl}/payment-codes/batch`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${authToken}`
-    },
-    body: JSON.stringify({
-      from: from4,
-      settlementNetwork: net.settlementNetwork,
-      usdcContract: usdc,
-      ...payee ? { payee } : {},
-      codes: signedCodes
-    })
-  });
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({}));
-    throw new Error(`Batch registration failed: ${err.error ?? res.status}`);
+      const res = await fetch(`${facilitatorUrl}/payment-codes`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          from: from4,
+          value,
+          validBefore,
+          usdcContract: usdc,
+          settlementNetwork: net.settlementNetwork,
+          escrowMode: true,
+          ...payee ? { payee } : {},
+          signature: signature2,
+          authorization
+        })
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        failed.push({ index, error: String(err.error ?? err.detail ?? res.status) });
+        continue;
+      }
+      const payload = await res.json();
+      results.push({
+        code: String(payload.code ?? ""),
+        validBefore: Number(payload.validBefore ?? validBefore),
+        expiresIn: Number(payload.expiresIn ?? validBefore - Math.floor(Date.now() / 1e3)),
+        locked: Boolean(payload.locked ?? payee)
+      });
+    } catch (error48) {
+      failed.push({
+        index,
+        error: error48 instanceof Error ? error48.message : String(error48)
+      });
+    }
   }
-  return res.json();
+  return {
+    registered: results.length,
+    codes: results,
+    failed,
+    relayerAddress: toAddress,
+    settlementNetwork: net.settlementNetwork
+  };
 }
 async function redeemPaymentCode(config2, code, payee) {
   const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR2;
@@ -5145,6 +5327,528 @@ async function payPayRequestWithSolana(config2, requestCode, wallet, options = {
   return res.json();
 }
 
+// src/current-payment-codes.ts
+import { ethers as ethers3 } from "ethers";
+import bs58 from "bs58";
+var DEFAULT_FACILITATOR4 = "https://relai.fi/facilitator";
+var TRANSFER_WITH_AUTHORIZATION_DOMAIN_VERSION = "2";
+var AUTHORIZATION_WINDOW_SECONDS2 = 3600;
+var EVM_ESCROW_ABI = ["function cancel(bytes8 code) external"];
+var EIP3009_TYPES3 = {
+  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" }
+  ]
+};
+function isEvmAddress(value) {
+  return /^0x[0-9a-fA-F]{40}$/i.test(value);
+}
+function codeToBytes8(code) {
+  const normalized = code.trim().toUpperCase();
+  const bytes = ethers3.toUtf8Bytes(normalized);
+  if (bytes.length !== 8) throw new Error("Payment code must be exactly 8 characters long");
+  return ethers3.hexlify(bytes);
+}
+function randomBytes323() {
+  const bytes = new Uint8Array(32);
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto?.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    const { randomBytes } = __require("crypto");
+    randomBytes(32).copy(Buffer.from(bytes.buffer));
+  }
+  return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+function extractClaimToken(claimUrlOrToken) {
+  const normalized = claimUrlOrToken.trim();
+  if (!normalized) throw new Error("Claim URL or claim token is required");
+  const directValue = normalized.split("?")[0]?.split("#")[0]?.trim() ?? "";
+  if (!directValue.includes("/")) return directValue;
+  try {
+    const url2 = new URL(normalized);
+    const segments = url2.pathname.split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? "";
+  } catch {
+    const segments = directValue.split("/").filter(Boolean);
+    return segments[segments.length - 1] ?? "";
+  }
+}
+function buildClaimUrl2(facilitatorUrl, claimToken) {
+  if (!claimToken) return null;
+  const origin = new URL(facilitatorUrl).origin;
+  return new URL(`/claim/${claimToken}`, origin).toString();
+}
+function buildCancelAuthorizationMessage(code, owner, issuedAt) {
+  return [
+    "RelAI Codes",
+    "Authorize payment code cancellation",
+    `Code: ${code.trim().toUpperCase()}`,
+    `Owner: ${owner.toLowerCase()}`,
+    `Issued At: ${issuedAt}`
+  ].join("\n");
+}
+function buildClaimLinkCancelAuthorizationMessage(claimToken, owner, issuedAt) {
+  return [
+    "RelAI Codes",
+    "Authorize claim link cancellation",
+    `Claim Token: ${claimToken}`,
+    `Owner: ${owner.toLowerCase()}`,
+    `Issued At: ${issuedAt}`
+  ].join("\n");
+}
+function buildEvmClaimLinkAuthorizationMessage(params) {
+  return [
+    "RelAI EVM Claim Link",
+    `Claim Token: ${params.claimToken}`,
+    `Claimer: ${params.claimer.toLowerCase()}`,
+    `Mode: ${params.mode}`,
+    `Target Address: ${params.targetAddress ?? "-"}`,
+    `Target Network: ${params.targetNetwork ?? "-"}`,
+    `Issued At: ${params.issuedAt}`
+  ].join("\n");
+}
+function buildSolanaClaimLinkAuthorizationMessage(params) {
+  return [
+    "RelAI Solana Claim Link",
+    `Claim Token: ${params.claimToken}`,
+    `Claimer: ${params.claimer}`,
+    `Mode: ${params.mode}`,
+    `Target Address: ${params.targetAddress ?? "-"}`,
+    `Target Network: ${params.targetNetwork ?? "-"}`,
+    `Issued At: ${params.issuedAt}`
+  ].join("\n");
+}
+async function readJson(response) {
+  return response.json().catch(() => ({}));
+}
+async function fetchWithPayload(url2, init) {
+  const response = await fetch(url2, init);
+  const payload = await readJson(response);
+  return { response, payload };
+}
+function buildRequestError(response, payload) {
+  return new Error(String(payload.error || payload.detail || payload.message || `Request failed (${response.status})`));
+}
+function isNotFoundResponse(response, payload) {
+  return response.status === 404 || payload.errorCode === "not_found";
+}
+async function fetchStoredCodeWithFallback(facilitatorUrl, normalizedCode, options = {}) {
+  const suffix = options.suffix ? `/${options.suffix.replace(/^\/+/, "")}` : "";
+  const attempts = [
+    { kind: "evm", url: `${facilitatorUrl}/payment-codes/${normalizedCode}${suffix}` },
+    { kind: "solana", url: `${facilitatorUrl}/solana-payment-codes/${normalizedCode}${suffix}` }
+  ];
+  let lastError = null;
+  for (const attempt of attempts) {
+    const { response, payload } = await fetchWithPayload(attempt.url, options.init);
+    if (response.ok) {
+      return { kind: attempt.kind, payload };
+    }
+    if (!isNotFoundResponse(response, payload)) {
+      throw buildRequestError(response, payload);
+    }
+    lastError = buildRequestError(response, payload);
+  }
+  throw lastError ?? new Error("Payment code not found");
+}
+async function fetchOrThrow(url2, init) {
+  const { response, payload } = await fetchWithPayload(url2, init);
+  if (!response.ok) {
+    throw buildRequestError(response, payload);
+  }
+  return payload;
+}
+function sanitizeClaimLinkResponse(payload, facilitatorUrl, fallbackClaimToken) {
+  const claimToken = typeof payload.claimToken === "string" ? payload.claimToken : fallbackClaimToken ?? null;
+  const sanitized = { ...payload };
+  delete sanitized.claimToken;
+  delete sanitized.id;
+  return {
+    ...sanitized,
+    claimUrl: buildClaimUrl2(facilitatorUrl, claimToken)
+  };
+}
+async function createPaymentCode(config2, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const ttlSeconds = Math.max(60, Math.round(Number(params.ttlSeconds ?? 86400)));
+  if ("wallet" in params) {
+    const amount3 = BigInt(params.amount);
+    if (amount3 <= 0n) throw new Error("amount must be positive");
+    return generateSolanaPaymentCode(config2, params.wallet, {
+      amount: amount3,
+      network: params.network,
+      claimLink: params.claimLink === true,
+      description: params.description,
+      ttlSeconds
+    });
+  }
+  const network = params.network ?? "base-sepolia";
+  const net = NETWORK_CONFIGS[network];
+  if (!net) throw new Error(`Unsupported network: ${network}`);
+  const amount2 = BigInt(params.amount);
+  if (amount2 <= 0n) throw new Error("amount must be positive");
+  const relayerConfig = await fetchOrThrow(`${facilitatorUrl}/payment-codes/relayer-address`);
+  const escrowAddresses = relayerConfig.escrowAddresses ?? {};
+  const escrowAddress = escrowAddresses[network];
+  if (!escrowAddress) throw new Error(`EVM escrow is not configured for ${network}`);
+  const from4 = await params.signer.getAddress();
+  const now = Math.floor(Date.now() / 1e3);
+  const validBefore = now + ttlSeconds;
+  const authorizationValidBefore = String(Math.min(validBefore, now + AUTHORIZATION_WINDOW_SECONDS2));
+  const authorizationNonce = randomBytes323();
+  const usdcContract = params.usdcContract ?? net.usdc;
+  const domain2 = {
+    name: net.domainName,
+    version: TRANSFER_WITH_AUTHORIZATION_DOMAIN_VERSION,
+    chainId: net.chainId,
+    verifyingContract: usdcContract
+  };
+  const authorization = {
+    from: from4,
+    to: escrowAddress,
+    value: amount2.toString(),
+    validAfter: "0",
+    validBefore: authorizationValidBefore,
+    nonce: authorizationNonce
+  };
+  const signature2 = await params.signer.signTypedData(domain2, EIP3009_TYPES3, authorization);
+  const payload = await fetchOrThrow(`${facilitatorUrl}/payment-codes`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      from: from4,
+      value: amount2.toString(),
+      validBefore,
+      usdcContract,
+      settlementNetwork: network,
+      escrowMode: true,
+      claimLink: params.claimLink === true,
+      ...params.description ? { description: params.description } : {},
+      ...params.payee ? { payee: params.payee } : {},
+      signature: signature2,
+      authorization
+    })
+  });
+  return params.claimLink === true ? sanitizeClaimLinkResponse(payload, facilitatorUrl) : payload;
+}
+async function createPaymentCodesBatch(config2, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  if (!Array.isArray(params.codes) || params.codes.length === 0) {
+    throw new Error("codes must not be empty");
+  }
+  if ("wallet" in params) {
+    const items = params.codes.map((item) => ({
+      amount: item.amount,
+      ttlSeconds: item.ttlSeconds,
+      description: item.description
+    }));
+    return generateSolanaPaymentCodesBatch(config2, params.wallet, {
+      network: params.network,
+      items
+    });
+  }
+  const network = params.network ?? "base-sepolia";
+  const net = NETWORK_CONFIGS[network];
+  if (!net) throw new Error(`Unsupported network: ${network}`);
+  const relayerConfig = await fetchOrThrow(`${facilitatorUrl}/payment-codes/relayer-address`);
+  const escrowAddresses = relayerConfig.escrowAddresses ?? {};
+  const escrowAddress = escrowAddresses[network];
+  if (!escrowAddress) throw new Error(`EVM escrow is not configured for ${network}`);
+  const from4 = await params.signer.getAddress();
+  const now = Math.floor(Date.now() / 1e3);
+  const usdcContract = params.usdcContract ?? net.usdc;
+  const normalizedCodes = params.codes.map((item) => {
+    const amount2 = BigInt(item.amount);
+    if (amount2 <= 0n) throw new Error("Each batch code amount must be positive");
+    const ttlSeconds = Math.max(60, Math.round(Number(item.ttlSeconds ?? 86400)));
+    return {
+      value: amount2,
+      validBefore: now + ttlSeconds,
+      description: item.description?.trim() || void 0
+    };
+  });
+  const totalAmount = normalizedCodes.reduce((sum, item) => sum + item.value, 0n);
+  const authorizationValidBefore = String(now + AUTHORIZATION_WINDOW_SECONDS2);
+  const authorizationNonce = randomBytes323();
+  const domain2 = {
+    name: net.domainName,
+    version: TRANSFER_WITH_AUTHORIZATION_DOMAIN_VERSION,
+    chainId: net.chainId,
+    verifyingContract: usdcContract
+  };
+  const authorization = {
+    from: from4,
+    to: escrowAddress,
+    value: totalAmount.toString(),
+    validAfter: "0",
+    validBefore: authorizationValidBefore,
+    nonce: authorizationNonce
+  };
+  const signature2 = await params.signer.signTypedData(domain2, EIP3009_TYPES3, authorization);
+  return fetchOrThrow(`${facilitatorUrl}/payment-codes/batch-funded`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      from: from4,
+      usdcContract,
+      settlementNetwork: network,
+      ...params.payee ? { payee: params.payee } : {},
+      signature: signature2,
+      authorization,
+      codes: normalizedCodes.map((item) => ({
+        value: item.value.toString(),
+        validBefore: item.validBefore,
+        ...item.description ? { description: item.description } : {}
+      }))
+    })
+  });
+}
+async function listOwnerPaymentCodes(config2, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  if (params.walletType === "solana") {
+    if (!params.wallet.publicKey) throw new Error("Solana wallet not connected");
+    const walletAddress2 = params.wallet.publicKey.toString();
+    const challenge2 = await fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/challenge`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ walletAddress: walletAddress2, walletType: "solana" })
+    });
+    const message2 = typeof challenge2.message === "string" ? challenge2.message : "";
+    if (!message2) throw new Error("Failed to load owner challenge message");
+    const signatureBytes = await params.wallet.signMessage(new TextEncoder().encode(message2));
+    const session2 = await fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/session`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ walletAddress: walletAddress2, walletType: "solana", signature: bs58.encode(signatureBytes) })
+    });
+    const accessToken2 = typeof session2.accessToken === "string" ? session2.accessToken : "";
+    if (!accessToken2) throw new Error("Failed to create owner session");
+    return fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/codes`, {
+      headers: { Authorization: `Bearer ${accessToken2}` }
+    });
+  }
+  const walletAddress = await params.wallet.getAddress();
+  const challenge = await fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/challenge`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ walletAddress, walletType: "evm" })
+  });
+  const message = typeof challenge.message === "string" ? challenge.message : "";
+  if (!message) throw new Error("Failed to load owner challenge message");
+  const session = await fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/session`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ walletAddress, walletType: "evm", signature: await params.wallet.signMessage(message) })
+  });
+  const accessToken = typeof session.accessToken === "string" ? session.accessToken : "";
+  if (!accessToken) throw new Error("Failed to create owner session");
+  return fetchOrThrow(`${facilitatorUrl}/payment-codes/owner/codes`, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+}
+async function getPaymentCode2(config2, code) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const normalizedCode = code.trim().toUpperCase();
+  const { payload } = await fetchStoredCodeWithFallback(facilitatorUrl, normalizedCode);
+  return payload;
+}
+var getPaymentCodeDetails = getPaymentCode2;
+async function redeemStoredPaymentCode(config2, code, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const normalizedCode = code.trim().toUpperCase();
+  const { payload } = await fetchStoredCodeWithFallback(facilitatorUrl, normalizedCode, {
+    suffix: "redeem",
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        payee: params.payee,
+        ...params.evmNetwork ? { evmNetwork: params.evmNetwork } : {},
+        ...params.solanaNetwork ? { solanaNetwork: params.solanaNetwork } : {}
+      })
+    }
+  });
+  return payload;
+}
+async function cancelStoredPaymentCode(config2, code, params = {}) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const normalizedCode = code.trim().toUpperCase();
+  const statusInfo = await fetchStoredCodeWithFallback(facilitatorUrl, normalizedCode);
+  if (statusInfo.kind === "solana") {
+    if (!params.solanaWallet) {
+      throw new Error("A Solana wallet is required to cancel this payment code");
+    }
+    return cancelSolanaPaymentCode(config2, normalizedCode, params.solanaWallet, {
+      network: params.network === "solana" || params.network === "solana-devnet" ? params.network : void 0
+    });
+  }
+  if (!params.wallet) {
+    throw new Error("An EVM wallet is required to cancel this payment code");
+  }
+  const status = statusInfo.payload;
+  const owner = await params.wallet.getAddress();
+  const network = params.network ?? String(status.settlementNetwork || "base-sepolia");
+  if (status.claimLink === true && typeof status.claimToken === "string" && status.escrowMode === true) {
+    const issuedAt2 = Date.now();
+    return fetchOrThrow(`${facilitatorUrl}/payment-codes/claim-links/evm/${status.claimToken}/cancel`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        owner,
+        issuedAt: issuedAt2,
+        signature: await params.wallet.signMessage(buildClaimLinkCancelAuthorizationMessage(status.claimToken, owner, issuedAt2))
+      })
+    });
+  }
+  if (status.escrowMode === true) {
+    if (!params.wallet.sendTransaction) {
+      throw new Error("This EVM wallet does not support sendTransaction, which is required for escrow cancellation");
+    }
+    const relayerConfig = await fetchOrThrow(`${facilitatorUrl}/payment-codes/relayer-address`);
+    const escrowAddresses = relayerConfig.escrowAddresses ?? {};
+    const escrowAddress = escrowAddresses[network];
+    if (!escrowAddress) throw new Error(`EVM escrow is not configured for ${network}`);
+    const cancelInterface = new ethers3.Interface(EVM_ESCROW_ABI);
+    const tx = await params.wallet.sendTransaction({
+      to: escrowAddress,
+      data: cancelInterface.encodeFunctionData("cancel", [codeToBytes8(normalizedCode)])
+    });
+    await tx.wait();
+    return {
+      success: true,
+      code: normalizedCode,
+      cancelTxHash: tx.hash,
+      network
+    };
+  }
+  const issuedAt = Date.now();
+  return fetchOrThrow(`${facilitatorUrl}/payment-codes/${normalizedCode}/cancel`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      owner,
+      issuedAt,
+      signature: await params.wallet.signMessage(buildCancelAuthorizationMessage(normalizedCode, owner, issuedAt))
+    })
+  });
+}
+async function claimPaymentLink(config2, claimUrlOrToken, params) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const claimToken = extractClaimToken(claimUrlOrToken);
+  if (!claimToken) throw new Error("Claim URL or claim token is required");
+  const issuedAt = Date.now();
+  const mode = params.mode ?? "claim-usdc";
+  if ("solanaWallet" in params && params.solanaWallet) {
+    if (!params.solanaWallet.publicKey) throw new Error("Solana wallet not connected");
+    const claimer2 = params.solanaWallet.publicKey.toString();
+    const requestedPayee2 = params.payee?.trim() || claimer2;
+    const targetAddress2 = mode === "claim-usdc" ? isEvmAddress(requestedPayee2) ? requestedPayee2.toLowerCase() : requestedPayee2 : null;
+    const targetNetwork2 = mode === "claim-usdc" ? targetAddress2 == null ? null : isEvmAddress(targetAddress2) ? params.evmNetwork ?? null : params.solanaNetwork ?? null : null;
+    const message2 = buildSolanaClaimLinkAuthorizationMessage({
+      claimToken,
+      claimer: claimer2,
+      issuedAt,
+      mode,
+      targetAddress: targetAddress2,
+      targetNetwork: targetNetwork2
+    });
+    const signatureBytes = await params.solanaWallet.signMessage(new TextEncoder().encode(message2));
+    const payload2 = await fetchOrThrow(`${facilitatorUrl}/solana-payment-codes/claim-links/${claimToken}/claim`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        claimer: claimer2,
+        issuedAt,
+        signature: bs58.encode(signatureBytes),
+        mode,
+        ...targetAddress2 ? { targetAddress: targetAddress2 } : {},
+        ...targetNetwork2 ? { targetNetwork: targetNetwork2 } : {}
+      })
+    });
+    return sanitizeClaimLinkResponse(payload2, facilitatorUrl, claimToken);
+  }
+  if (!("wallet" in params) || !params.wallet) {
+    throw new Error("An EVM wallet or Solana wallet is required to claim this payment link");
+  }
+  const claimer = (await params.wallet.getAddress()).toLowerCase();
+  const requestedPayee = params.payee?.trim() || claimer;
+  const targetAddress = mode === "claim-usdc" ? isEvmAddress(requestedPayee) ? requestedPayee.toLowerCase() : requestedPayee : null;
+  const targetNetwork = mode === "claim-usdc" ? targetAddress == null ? null : isEvmAddress(targetAddress) ? params.evmNetwork ?? null : params.solanaNetwork ?? null : null;
+  const message = buildEvmClaimLinkAuthorizationMessage({
+    claimToken,
+    claimer,
+    issuedAt,
+    mode,
+    targetAddress,
+    targetNetwork
+  });
+  const payload = await fetchOrThrow(`${facilitatorUrl}/payment-codes/claim-links/evm/${claimToken}/claim`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      claimer,
+      issuedAt,
+      signature: await params.wallet.signMessage(message),
+      mode,
+      ...targetAddress ? { targetAddress, payee: targetAddress } : {},
+      ...targetNetwork ? { targetNetwork } : {},
+      ...targetAddress && isEvmAddress(targetAddress) && targetNetwork ? { evmNetwork: targetNetwork } : {},
+      ...targetAddress && !isEvmAddress(targetAddress) && targetNetwork ? { solanaNetwork: targetNetwork } : {}
+    })
+  });
+  return sanitizeClaimLinkResponse(payload, facilitatorUrl, claimToken);
+}
+async function payPayRequestWithStoredCode(config2, requestCode, paymentCode, options = {}) {
+  const facilitatorUrl = config2.facilitatorUrl ?? DEFAULT_FACILITATOR4;
+  const normalizedRequestCode = requestCode.trim().toUpperCase();
+  const normalizedPaymentCode = paymentCode.trim().toUpperCase();
+  const codeStatusInfo = await fetchStoredCodeWithFallback(facilitatorUrl, normalizedPaymentCode);
+  if (codeStatusInfo.kind === "solana") {
+    return fetchOrThrow(`${facilitatorUrl}/solana-payment-codes/${normalizedPaymentCode}/pay-request`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        requestCode: normalizedRequestCode,
+        ...options.changeAddress ? { changeAddress: options.changeAddress } : {}
+      })
+    });
+  }
+  const requestInfo = await getPayRequest(config2, normalizedRequestCode);
+  const codeStatus = codeStatusInfo.payload;
+  const allowOverpayment = options.allowOverpayment ?? true;
+  const returnChange = options.returnChange ?? "code";
+  const codeValue = BigInt(String(codeStatus.value ?? 0));
+  const requestAmount = BigInt(requestInfo.amount);
+  if (codeValue < requestAmount) {
+    throw new Error(
+      `Payment code value (${Number(codeValue) / 1e6} USDC) is less than the request amount (${Number(requestAmount) / 1e6} USDC)`
+    );
+  }
+  if (!allowOverpayment && codeValue > requestAmount) {
+    throw new Error(
+      `Payment code value (${Number(codeValue) / 1e6} USDC) exceeds the request amount (${Number(requestAmount) / 1e6} USDC)`
+    );
+  }
+  const merchantAddress = String(requestInfo.to);
+  const requestNetwork = String(requestInfo.network);
+  const usePartial = codeValue > requestAmount;
+  return fetchOrThrow(`${facilitatorUrl}/payment-codes/${normalizedPaymentCode}/redeem`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      payee: merchantAddress,
+      ...usePartial ? { invoiceAmount: requestInfo.amount.toString() } : {},
+      ...usePartial ? { returnChangeAsCode: returnChange === "code" } : {},
+      ...usePartial && options.changeAddress ? { changeAddress: options.changeAddress } : {},
+      ...isEvmAddress(merchantAddress) ? { evmNetwork: requestNetwork } : { solanaNetwork: requestNetwork }
+    })
+  });
+}
+
 // src/utils/payload-converter.ts
 var NETWORK_V1_TO_V2 = {
   "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
@@ -18924,10 +19628,14 @@ export {
   USDC_SOLANA,
   cancelPaymentCode,
   cancelSolanaPaymentCode,
+  cancelStoredPaymentCode,
+  claimPaymentLink,
   convertPayloadToVersion,
   convertV1ToV2,
   convertV2ToV1,
   createPayRequest,
+  createPaymentCode,
+  createPaymentCodesBatch,
   createPrivateKeySigner,
   createX402Client,
   Relai as default,
@@ -18942,11 +19650,13 @@ export {
   generateSolanaPaymentCode,
   getPayRequest,
   getPaymentCode,
+  getPaymentCodeDetails,
   getSolanaPaymentCode,
   isEvm,
   isEvmNetwork,
   isSolana,
   isSolanaNetwork,
+  listOwnerPaymentCodes,
   networkV1ToV2,
   networkV2ToV1,
   normalizeNetwork,
@@ -18954,8 +19664,10 @@ export {
   payPayRequest,
   payPayRequestWithCode,
   payPayRequestWithSolana,
+  payPayRequestWithStoredCode,
   redeemPaymentCode,
   redeemSolanaPaymentCode,
+  redeemStoredPaymentCode,
   resolveToken,
   stripePayTo,
   submitRelayFeedback,