@veil-cash/sdk 0.6.5 → 0.7.0

package/dist/index.cjs

@@ -10,6 +10,9 @@ var chains = require('viem/chains');
 var MerkleTree = require('fixed-merkle-tree-legacy');
 var snarkjs = require('snarkjs');
 var ffjavascript = require('ffjavascript');
+var client = require('@x402/core/client');
+var client$1 = require('@x402/evm/exact/client');
+var evm = require('@x402/evm');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -55,7 +58,9 @@ var poseidonHash2 = (a, b) => poseidonHash([a, b]);
 var randomBN = (nbytes = 31) => {
   const cryptoApi = globalThis.crypto;
   if (!cryptoApi?.getRandomValues) {
-    throw new Error("Secure random number generation is unavailable in this runtime");
+    throw new Error(
+      "Secure random number generation is unavailable. Provide globalThis.crypto.getRandomValues in this runtime."
+    );
   }
   const bytes = cryptoApi.getRandomValues(new Uint8Array(nbytes));
   let hex = "0x";
@@ -627,14 +632,6 @@ var QUEUE_ABI = [
     outputs: [{ name: "count", type: "uint256" }],
     stateMutability: "view",
     type: "function"
-  },
-  // Get remaining daily free deposits for an address (V3+)
-  {
-    inputs: [{ name: "_depositor", type: "address" }],
-    name: "getDailyFreeRemaining",
-    outputs: [{ name: "remaining", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
   }
 ];
 var POOL_ABI = [
@@ -1352,25 +1349,6 @@ async function getQueueBalance(options) {
     pendingCount: pendingDeposits.length
   };
 }
-async function getDailyFreeRemaining(options) {
-  const { address, pool = "eth", rpcUrl } = options;
-  const queueAddress = getQueueAddress(pool);
-  const publicClient = viem.createPublicClient({
-    chain: chains.base,
-    transport: viem.http(rpcUrl)
-  });
-  try {
-    const remaining = await publicClient.readContract({
-      address: queueAddress,
-      abi: QUEUE_ABI,
-      functionName: "getDailyFreeRemaining",
-      args: [address]
-    });
-    return Number(remaining);
-  } catch {
-    return 0;
-  }
-}
 async function getPrivateBalance(options) {
   const { keypair, pool = "eth", rpcUrl, onProgress } = options;
   const poolAddress = getPoolAddress(pool);
@@ -1950,12 +1928,13 @@ async function buildWithdrawProof(options) {
   };
 }
 async function withdraw(options) {
-  const { amount, recipient, pool = "eth", onProgress } = options;
+  const { amount, recipient, pool = "eth", onProgress, relayUrl } = options;
   const proof = await buildWithdrawProof(options);
   onProgress?.("Submitting to relay...");
   const relayResult = await submitRelay({
     type: "withdraw",
     pool,
+    relayUrl,
     proofArgs: proof.proofArgs,
     extData: proof.extData,
     metadata: {
@@ -1973,6 +1952,333 @@ async function withdraw(options) {
     recipient
   };
 }
+var X402_PAYER_DOMAIN = "veil-x402-payer";
+var BASE_NETWORK = `eip155:${ADDRESSES.chainId}`;
+var USDC_DECIMALS = POOL_CONFIG.usdc.decimals;
+var X402_MIN_WITHDRAW_ATOMIC = 1000n;
+function assertPrivateKey(value, label) {
+  if (!/^0x[a-fA-F0-9]{64}$/.test(value)) {
+    throw new Error(`${label} must be a 0x-prefixed 32-byte hex string`);
+  }
+}
+function normalizePayerIndex(index) {
+  const normalized = typeof index === "bigint" ? index : typeof index === "number" ? BigInt(index) : BigInt(index);
+  if (normalized < 0n) {
+    throw new Error("payerIndex must be non-negative");
+  }
+  return normalized;
+}
+function normalizeAtomicAmount(amount) {
+  if (!/^\d+$/.test(amount)) {
+    throw new Error(`x402 amount must be an atomic integer string, received: ${amount}`);
+  }
+  if (BigInt(amount) <= 0n) {
+    throw new Error("x402 amount must be greater than 0");
+  }
+  return amount;
+}
+function usdcAtomicToDecimalString(amountAtomic) {
+  const atomic = typeof amountAtomic === "bigint" ? amountAtomic.toString() : normalizeAtomicAmount(amountAtomic);
+  return viem.formatUnits(BigInt(atomic), USDC_DECIMALS);
+}
+function usdcDecimalToAtomic(amount) {
+  if (!/^\d+(\.\d+)?$/.test(amount.trim())) {
+    throw new Error(`Invalid USDC amount: ${amount}`);
+  }
+  return viem.parseUnits(amount.trim(), USDC_DECIMALS);
+}
+function deriveX402PayerKey(rootPrivateKey, index) {
+  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  const normalizedIndex = normalizePayerIndex(index);
+  return viem.keccak256(
+    viem.encodePacked(
+      ["bytes32", "string", "uint256"],
+      [rootPrivateKey, X402_PAYER_DOMAIN, normalizedIndex]
+    )
+  );
+}
+function deriveX402PayerAddress(rootPrivateKey, index) {
+  return accounts.privateKeyToAddress(deriveX402PayerKey(rootPrivateKey, index));
+}
+function selectBaseUsdcExactRequirement(paymentRequired) {
+  if (paymentRequired.x402Version !== 2) {
+    throw new Error(`Unsupported x402 version ${paymentRequired.x402Version}; expected v2`);
+  }
+  const requirement = paymentRequired.accepts.find(
+    (candidate) => candidate.scheme === "exact" && candidate.network === BASE_NETWORK && candidate.asset.toLowerCase() === ADDRESSES.usdcToken.toLowerCase()
+  );
+  if (!requirement) {
+    throw new Error("No supported x402 payment requirement found. Veil supports x402 v2 exact Base USDC only.");
+  }
+  if (!viem.isAddress(requirement.payTo)) {
+    throw new Error("Selected x402 requirement has an invalid payTo address");
+  }
+  normalizeAtomicAmount(requirement.amount);
+  return requirement;
+}
+async function parsePaymentRequired(response, httpClient) {
+  let body;
+  try {
+    body = await response.clone().json();
+  } catch {
+    body = void 0;
+  }
+  return httpClient.getPaymentRequiredResponse(
+    (name) => response.headers.get(name),
+    body
+  );
+}
+async function payX402Resource(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("fetch is not available; pass fetchImpl");
+  }
+  const payerIndex = normalizePayerIndex(options.payerIndex);
+  const payerPrivateKey = deriveX402PayerKey(options.rootPrivateKey, payerIndex);
+  const payerAccount = accounts.privateKeyToAccount(payerPrivateKey);
+  const publicClient = viem.createPublicClient({
+    chain: chains.base,
+    transport: viem.http(options.rpcUrl)
+  });
+  const signer = evm.toClientEvmSigner(payerAccount, publicClient);
+  const client$2 = new client.x402Client(
+    (_version, requirements) => selectBaseUsdcExactRequirement({
+      x402Version: 2,
+      resource: { url: options.url },
+      accepts: requirements
+    })
+  );
+  client$1.registerExactEvmScheme(client$2, {
+    signer,
+    networks: [BASE_NETWORK],
+    schemeOptions: options.rpcUrl ? { rpcUrl: options.rpcUrl } : void 0
+  });
+  const httpClient = new client.x402HTTPClient(client$2);
+  options.onProgress?.("Fetching x402 requirement...");
+  const initialResponse = await fetchImpl(options.url, options.init);
+  if (initialResponse.status !== 402) {
+    return {
+      response: initialResponse,
+      payerAddress: payerAccount.address,
+      payerIndex: payerIndex.toString(),
+      amount: "0",
+      amountAtomic: "0",
+      relayTransactionHash: "",
+      relayBlockNumber: ""
+    };
+  }
+  const paymentRequired = await parsePaymentRequired(initialResponse, httpClient);
+  const requirement = selectBaseUsdcExactRequirement(paymentRequired);
+  const amountAtomic = normalizeAtomicAmount(requirement.amount);
+  const amount = usdcAtomicToDecimalString(amountAtomic);
+  if (options.maxPayment !== void 0) {
+    const maxAtomic = usdcDecimalToAtomic(options.maxPayment);
+    if (BigInt(amountAtomic) > maxAtomic) {
+      throw new Error(
+        `x402 payment of ${amount} USDC exceeds maxPayment cap of ${usdcAtomicToDecimalString(maxAtomic)} USDC. Payment was not sent.`
+      );
+    }
+  }
+  let relayTransactionHash = "";
+  let relayBlockNumber = "";
+  let fundAtomic = BigInt(amountAtomic);
+  if (options.reuseExistingBalance) {
+    const payerBalance = await publicClient.readContract({
+      address: ADDRESSES.usdcToken,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [payerAccount.address]
+    });
+    if (payerBalance >= BigInt(amountAtomic)) {
+      fundAtomic = 0n;
+    } else if (options.reuseExistingBalance === "topup") {
+      fundAtomic = BigInt(amountAtomic) - payerBalance;
+    } else {
+      throw new Error(
+        `Cannot reuse payer index ${payerIndex.toString()}: holds ${viem.formatUnits(payerBalance, USDC_DECIMALS)} USDC but the resource requires ${amount} USDC. Pass reuseExistingBalance: 'topup' to fund the shortfall.`
+      );
+    }
+  }
+  if (fundAtomic === 0n) {
+    options.onProgress?.("Reusing funded x402 payer...", `${amount} USDC on ${payerAccount.address}`);
+  } else {
+    if (fundAtomic < X402_MIN_WITHDRAW_ATOMIC) {
+      fundAtomic = X402_MIN_WITHDRAW_ATOMIC;
+    }
+    const fundAmount = usdcAtomicToDecimalString(fundAtomic);
+    options.onProgress?.("Funding x402 payer...", `${fundAmount} USDC to ${payerAccount.address}`);
+    const proof = await buildWithdrawProof({
+      amount: fundAmount,
+      recipient: payerAccount.address,
+      keypair: new Keypair(options.rootPrivateKey),
+      pool: "usdc",
+      rpcUrl: options.rpcUrl,
+      provingKeyPath: options.provingKeyPath,
+      onProgress: options.onProgress
+    });
+    const relayResult = await submitRelay({
+      type: "withdraw",
+      pool: "usdc",
+      // x402 funding must target the low-minimum /x402 relay route. Default to it
+      // so direct SDK consumers do not silently hit the main relay's 5 USDC floor.
+      relayUrl: options.relayUrl ?? `${getRelayUrl()}/x402`,
+      proofArgs: proof.proofArgs,
+      extData: proof.extData,
+      metadata: {
+        amount: fundAmount,
+        amountAtomic: fundAtomic.toString(),
+        recipient: payerAccount.address,
+        inputUtxoCount: proof.inputCount,
+        outputUtxoCount: proof.outputCount,
+        x402: true,
+        payerIndex: payerIndex.toString()
+      }
+    });
+    relayTransactionHash = relayResult.transactionHash;
+    relayBlockNumber = relayResult.blockNumber;
+    if (options.onPayerFunded) {
+      try {
+        options.onPayerFunded({
+          payerAddress: payerAccount.address,
+          payerIndex: payerIndex.toString(),
+          amount,
+          amountAtomic,
+          relayTransactionHash,
+          relayBlockNumber
+        });
+      } catch {
+      }
+    }
+  }
+  options.onProgress?.("Signing x402 payment...");
+  const paymentPayload = await httpClient.createPaymentPayload({
+    ...paymentRequired,
+    accepts: [requirement]
+  });
+  const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);
+  const headers = new Headers(options.init?.headers);
+  for (const [key, value] of Object.entries(paymentHeaders)) {
+    headers.set(key, value);
+  }
+  options.onProgress?.("Requesting paid resource...");
+  const paidResponse = await fetchImpl(options.url, {
+    ...options.init,
+    headers
+  });
+  let paymentResponse;
+  try {
+    paymentResponse = httpClient.getPaymentSettleResponse((name) => paidResponse.headers.get(name));
+  } catch {
+    paymentResponse = void 0;
+  }
+  return {
+    response: paidResponse,
+    payerAddress: payerAccount.address,
+    payerIndex: payerIndex.toString(),
+    amount,
+    amountAtomic,
+    relayTransactionHash,
+    relayBlockNumber,
+    paymentResponse,
+    paymentTransactionHash: paymentResponse?.transaction
+  };
+}
+async function quoteX402Resource(options) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (!fetchImpl) {
+    throw new Error("fetch is not available; pass fetchImpl");
+  }
+  const client$1 = new client.x402Client(
+    (_version, requirements) => selectBaseUsdcExactRequirement({
+      x402Version: 2,
+      resource: { url: options.url },
+      accepts: requirements
+    })
+  );
+  const httpClient = new client.x402HTTPClient(client$1);
+  const initialResponse = await fetchImpl(options.url, options.init);
+  if (initialResponse.status !== 402) {
+    let body;
+    try {
+      body = await initialResponse.clone().json();
+    } catch {
+      try {
+        body = await initialResponse.clone().text();
+      } catch {
+        body = void 0;
+      }
+    }
+    return {
+      requiresPayment: false,
+      supported: false,
+      status: initialResponse.status,
+      body
+    };
+  }
+  let requirement;
+  try {
+    const paymentRequired = await parsePaymentRequired(initialResponse, httpClient);
+    requirement = selectBaseUsdcExactRequirement(paymentRequired);
+  } catch (error) {
+    return {
+      requiresPayment: true,
+      supported: false,
+      status: 402,
+      error: error instanceof Error ? error.message : "Unsupported x402 requirement"
+    };
+  }
+  const amountAtomic = normalizeAtomicAmount(requirement.amount);
+  const amount = usdcAtomicToDecimalString(amountAtomic);
+  let exceedsMax;
+  if (options.maxPayment !== void 0) {
+    exceedsMax = BigInt(amountAtomic) > usdcDecimalToAtomic(options.maxPayment);
+  }
+  return {
+    requiresPayment: true,
+    supported: true,
+    status: 402,
+    amount,
+    amountAtomic,
+    payTo: requirement.payTo,
+    network: requirement.network,
+    asset: requirement.asset,
+    exceedsMax,
+    maxPayment: options.maxPayment
+  };
+}
+async function getX402PayerBalances(options) {
+  assertPrivateKey(options.rootPrivateKey, "rootPrivateKey");
+  const start = normalizePayerIndex(options.startIndex ?? 0n);
+  const count = options.count ?? 16;
+  if (!Number.isInteger(count) || count <= 0 || count > 256) {
+    throw new Error("count must be an integer between 1 and 256");
+  }
+  const publicClient = viem.createPublicClient({
+    chain: chains.base,
+    transport: viem.http(options.rpcUrl)
+  });
+  const results = [];
+  for (let i = 0; i < count; i++) {
+    const index = start + BigInt(i);
+    const payerAddress = deriveX402PayerAddress(options.rootPrivateKey, index);
+    const balance = await publicClient.readContract({
+      address: ADDRESSES.usdcToken,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [payerAddress]
+    });
+    if (options.nonZeroOnly && balance === 0n) {
+      continue;
+    }
+    results.push({
+      payerIndex: index.toString(),
+      payerAddress,
+      usdc: viem.formatUnits(balance, USDC_DECIMALS),
+      usdcAtomic: balance.toString()
+    });
+  }
+  return results;
+}
 async function checkRecipientRegistration(address, rpcUrl) {
   const addresses = getAddresses();
   const publicClient = viem.createPublicClient({
@@ -2261,7 +2567,7 @@ function createBaseClient(rpcUrl) {
     transport: viem.http(rpcUrl)
   });
 }
-function assertPrivateKey(value, label) {
+function assertPrivateKey2(value, label) {
   if (!/^0x[a-fA-F0-9]{64}$/.test(value)) {
     throw new Error(`${label} must be a 0x-prefixed 32-byte hex string`);
   }
@@ -2296,7 +2602,7 @@ function normalizeDeadline(deadline) {
   return nextDeadline;
 }
 function deriveSubaccountChildPrivateKey(rootPrivateKey, slot) {
-  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(rootPrivateKey, "rootPrivateKey");
   const normalizedSlot = normalizeSlot(slot);
   return viem.keccak256(
     viem.encodePacked(
@@ -2306,7 +2612,7 @@ function deriveSubaccountChildPrivateKey(rootPrivateKey, slot) {
   );
 }
 function deriveSubaccountSalt(rootPrivateKey, slot) {
-  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(rootPrivateKey, "rootPrivateKey");
   const normalizedSlot = normalizeSlot(slot);
   return viem.keccak256(
     viem.encodePacked(
@@ -2316,11 +2622,11 @@ function deriveSubaccountSalt(rootPrivateKey, slot) {
   );
 }
 function deriveSubaccountChildOwner(childPrivateKey) {
-  assertPrivateKey(childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(childPrivateKey, "childPrivateKey");
   return accounts.privateKeyToAddress(childPrivateKey);
 }
 function deriveSubaccountChildDepositKey(childPrivateKey) {
-  assertPrivateKey(childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(childPrivateKey, "childPrivateKey");
   return new Keypair(childPrivateKey).depositKey();
 }
 async function predictSubaccountForwarder(options) {
@@ -2413,7 +2719,7 @@ function toPrivateBalanceStatus(result) {
 }
 async function getSubaccountPrivateBalance(options) {
   const normalizedSlot = normalizeSlot(options.slot);
-  assertPrivateKey(options.rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(options.rootPrivateKey, "rootPrivateKey");
   const childPrivateKey = deriveSubaccountChildPrivateKey(options.rootPrivateKey, normalizedSlot);
   const childKeypair = new Keypair(childPrivateKey);
   return getPrivateBalance({
@@ -2523,7 +2829,7 @@ function buildSubaccountWithdrawTypedData(options) {
   };
 }
 async function signSubaccountWithdraw(options) {
-  assertPrivateKey(options.childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(options.childPrivateKey, "childPrivateKey");
   const account = accounts.privateKeyToAccount(options.childPrivateKey);
   return account.signTypedData({
     domain: options.typedData.domain,
@@ -2636,7 +2942,7 @@ async function mergeSubaccount(options) {
     onProgress
   } = options;
   const normalizedSlot = normalizeSlot(slot);
-  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(rootPrivateKey, "rootPrivateKey");
   const poolConfig = POOL_CONFIG[pool];
   const poolAddress = getPoolAddress(pool);
   const childPrivateKey = deriveSubaccountChildPrivateKey(rootPrivateKey, normalizedSlot);
@@ -2795,9 +3101,10 @@ exports.deriveSubaccountChildOwner = deriveSubaccountChildOwner;
 exports.deriveSubaccountChildPrivateKey = deriveSubaccountChildPrivateKey;
 exports.deriveSubaccountSalt = deriveSubaccountSalt;
 exports.deriveSubaccountSlot = deriveSubaccountSlot;
+exports.deriveX402PayerAddress = deriveX402PayerAddress;
+exports.deriveX402PayerKey = deriveX402PayerKey;
 exports.findNextSubaccountWithdrawNonce = findNextSubaccountWithdrawNonce;
 exports.getAddresses = getAddresses;
-exports.getDailyFreeRemaining = getDailyFreeRemaining;
 exports.getExtDataHash = getExtDataHash;
 exports.getForwarderFactoryAddress = getForwarderFactoryAddress;
 exports.getMerklePath = getMerklePath;
@@ -2809,17 +3116,21 @@ exports.getRelayInfo = getRelayInfo;
 exports.getRelayUrl = getRelayUrl;
 exports.getSubaccountPrivateBalance = getSubaccountPrivateBalance;
 exports.getSubaccountStatus = getSubaccountStatus;
+exports.getX402PayerBalances = getX402PayerBalances;
 exports.isSubaccountForwarderDeployed = isSubaccountForwarderDeployed;
 exports.isSubaccountWithdrawNonceUsed = isSubaccountWithdrawNonceUsed;
 exports.mergeSubaccount = mergeSubaccount;
 exports.mergeUtxos = mergeUtxos;
 exports.packEncryptedMessage = packEncryptedMessage;
+exports.payX402Resource = payX402Resource;
 exports.poseidonHash = poseidonHash;
 exports.poseidonHash2 = poseidonHash2;
 exports.predictSubaccountForwarder = predictSubaccountForwarder;
 exports.prepareTransaction = prepareTransaction;
 exports.prove = prove;
+exports.quoteX402Resource = quoteX402Resource;
 exports.randomBN = randomBN;
+exports.selectBaseUsdcExactRequirement = selectBaseUsdcExactRequirement;
 exports.selectCircuit = selectCircuit;
 exports.selectUtxosForWithdraw = selectUtxosForWithdraw;
 exports.shuffle = shuffle;
@@ -2830,6 +3141,8 @@ exports.toBuffer = toBuffer;
 exports.toFixedHex = toFixedHex;
 exports.transfer = transfer;
 exports.unpackEncryptedMessage = unpackEncryptedMessage;
+exports.usdcAtomicToDecimalString = usdcAtomicToDecimalString;
+exports.usdcDecimalToAtomic = usdcDecimalToAtomic;
 exports.withdraw = withdraw;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map