@veil-cash/sdk 0.6.4 → 0.7.0

package/dist/index.js

@@ -1,15 +1,27 @@
 import { ethers } from 'ethers';
 import { Buffer } from 'buffer';
 import { privateKeyToAccount, privateKeyToAddress } from 'viem/accounts';
-import ethSigUtil from 'eth-sig-util';
-import circomlib from 'circomlib';
+import * as _ethSigUtil from 'eth-sig-util';
+import * as _circomlib from 'circomlib';
 import { encodeFunctionData, parseEther, parseUnits, createPublicClient, http, formatUnits, keccak256, encodePacked, isAddress, formatEther } from 'viem';
 import { base } from 'viem/chains';
 import MerkleTree from 'fixed-merkle-tree-legacy';
 import { groth16 } from 'snarkjs';
 import { utils } from 'ffjavascript';
+import { x402Client, x402HTTPClient } from '@x402/core/client';
+import { registerExactEvmScheme } from '@x402/evm/exact/client';
+import { toClientEvmSigner } from '@x402/evm';
 
 // src/keypair.ts
+function resolveInterop(mod) {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    const defaultVal = mod.default;
+    if (defaultVal != null) return defaultVal;
+  }
+  return mod;
+}
+var ethSigUtil = resolveInterop(_ethSigUtil);
+var circomlib = resolveInterop(_circomlib);
 var poseidon = circomlib.poseidon;
 var FIELD_SIZE = BigInt(
   "21888242871839275222246405745257275088548364400416034343698204186575808495617"
@@ -19,7 +31,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";
@@ -591,14 +605,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 = [
@@ -1316,25 +1322,6 @@ async function getQueueBalance(options) {
     pendingCount: pendingDeposits.length
   };
 }
-async function getDailyFreeRemaining(options) {
-  const { address, pool = "eth", rpcUrl } = options;
-  const queueAddress = getQueueAddress(pool);
-  const publicClient = createPublicClient({
-    chain: base,
-    transport: 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);
@@ -1914,12 +1901,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: {
@@ -1937,6 +1925,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 formatUnits(BigInt(atomic), USDC_DECIMALS);
+}
+function usdcDecimalToAtomic(amount) {
+  if (!/^\d+(\.\d+)?$/.test(amount.trim())) {
+    throw new Error(`Invalid USDC amount: ${amount}`);
+  }
+  return parseUnits(amount.trim(), USDC_DECIMALS);
+}
+function deriveX402PayerKey(rootPrivateKey, index) {
+  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  const normalizedIndex = normalizePayerIndex(index);
+  return keccak256(
+    encodePacked(
+      ["bytes32", "string", "uint256"],
+      [rootPrivateKey, X402_PAYER_DOMAIN, normalizedIndex]
+    )
+  );
+}
+function deriveX402PayerAddress(rootPrivateKey, index) {
+  return 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 (!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 = privateKeyToAccount(payerPrivateKey);
+  const publicClient = createPublicClient({
+    chain: base,
+    transport: http(options.rpcUrl)
+  });
+  const signer = toClientEvmSigner(payerAccount, publicClient);
+  const client = new x402Client(
+    (_version, requirements) => selectBaseUsdcExactRequirement({
+      x402Version: 2,
+      resource: { url: options.url },
+      accepts: requirements
+    })
+  );
+  registerExactEvmScheme(client, {
+    signer,
+    networks: [BASE_NETWORK],
+    schemeOptions: options.rpcUrl ? { rpcUrl: options.rpcUrl } : void 0
+  });
+  const httpClient = new x402HTTPClient(client);
+  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 ${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 = new x402Client(
+    (_version, requirements) => selectBaseUsdcExactRequirement({
+      x402Version: 2,
+      resource: { url: options.url },
+      accepts: requirements
+    })
+  );
+  const httpClient = new x402HTTPClient(client);
+  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 = createPublicClient({
+    chain: base,
+    transport: 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: formatUnits(balance, USDC_DECIMALS),
+      usdcAtomic: balance.toString()
+    });
+  }
+  return results;
+}
 async function checkRecipientRegistration(address, rpcUrl) {
   const addresses = getAddresses();
   const publicClient = createPublicClient({
@@ -2225,7 +2540,7 @@ function createBaseClient(rpcUrl) {
     transport: 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`);
   }
@@ -2260,7 +2575,7 @@ function normalizeDeadline(deadline) {
   return nextDeadline;
 }
 function deriveSubaccountChildPrivateKey(rootPrivateKey, slot) {
-  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(rootPrivateKey, "rootPrivateKey");
   const normalizedSlot = normalizeSlot(slot);
   return keccak256(
     encodePacked(
@@ -2270,7 +2585,7 @@ function deriveSubaccountChildPrivateKey(rootPrivateKey, slot) {
   );
 }
 function deriveSubaccountSalt(rootPrivateKey, slot) {
-  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  assertPrivateKey2(rootPrivateKey, "rootPrivateKey");
   const normalizedSlot = normalizeSlot(slot);
   return keccak256(
     encodePacked(
@@ -2280,11 +2595,11 @@ function deriveSubaccountSalt(rootPrivateKey, slot) {
   );
 }
 function deriveSubaccountChildOwner(childPrivateKey) {
-  assertPrivateKey(childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(childPrivateKey, "childPrivateKey");
   return privateKeyToAddress(childPrivateKey);
 }
 function deriveSubaccountChildDepositKey(childPrivateKey) {
-  assertPrivateKey(childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(childPrivateKey, "childPrivateKey");
   return new Keypair(childPrivateKey).depositKey();
 }
 async function predictSubaccountForwarder(options) {
@@ -2377,7 +2692,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({
@@ -2487,7 +2802,7 @@ function buildSubaccountWithdrawTypedData(options) {
   };
 }
 async function signSubaccountWithdraw(options) {
-  assertPrivateKey(options.childPrivateKey, "childPrivateKey");
+  assertPrivateKey2(options.childPrivateKey, "childPrivateKey");
   const account = privateKeyToAccount(options.childPrivateKey);
   return account.signTypedData({
     domain: options.typedData.domain,
@@ -2600,7 +2915,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);
@@ -2723,6 +3038,6 @@ async function mergeSubaccount(options) {
   };
 }
 
-export { ADDRESSES, CIRCUIT_CONFIG, ENTRY_ABI, ERC20_ABI, FIELD_SIZE, FORWARDER_ABI, FORWARDER_CONTRACT_VERSION, FORWARDER_FACTORY_ABI, Keypair, MAX_SUBACCOUNT_SLOTS, MERKLE_TREE_HEIGHT, POOL_ABI, POOL_CONFIG, QUEUE_ABI, RelayError, Utxo, VEIL_SIGNED_MESSAGE, buildApproveUSDCTx, buildChangeDepositKeyTx, buildDepositETHTx, buildDepositTx, buildDepositUSDCTx, buildMerkleTree, buildRegisterTx, buildSubaccountRecoveryTx, buildSubaccountWithdrawTypedData, buildTransferProof, buildWithdrawProof, checkRecipientRegistration, checkRelayHealth, deploySubaccountForwarder, deriveSubaccountChildDepositKey, deriveSubaccountChildOwner, deriveSubaccountChildPrivateKey, deriveSubaccountSalt, deriveSubaccountSlot, findNextSubaccountWithdrawNonce, getAddresses, getDailyFreeRemaining, getExtDataHash, getForwarderFactoryAddress, getMerklePath, getPoolAddress, getPrivateBalance, getQueueAddress, getQueueBalance, getRelayInfo, getRelayUrl, getSubaccountPrivateBalance, getSubaccountStatus, isSubaccountForwarderDeployed, isSubaccountWithdrawNonceUsed, mergeSubaccount, mergeUtxos, packEncryptedMessage, poseidonHash, poseidonHash2, predictSubaccountForwarder, prepareTransaction, prove, randomBN, selectCircuit, selectUtxosForWithdraw, shuffle, signSubaccountWithdraw, submitRelay, sweepSubaccountForwarder, toBuffer, toFixedHex, transfer, unpackEncryptedMessage, withdraw };
+export { ADDRESSES, CIRCUIT_CONFIG, ENTRY_ABI, ERC20_ABI, FIELD_SIZE, FORWARDER_ABI, FORWARDER_CONTRACT_VERSION, FORWARDER_FACTORY_ABI, Keypair, MAX_SUBACCOUNT_SLOTS, MERKLE_TREE_HEIGHT, POOL_ABI, POOL_CONFIG, QUEUE_ABI, RelayError, Utxo, VEIL_SIGNED_MESSAGE, buildApproveUSDCTx, buildChangeDepositKeyTx, buildDepositETHTx, buildDepositTx, buildDepositUSDCTx, buildMerkleTree, buildRegisterTx, buildSubaccountRecoveryTx, buildSubaccountWithdrawTypedData, buildTransferProof, buildWithdrawProof, checkRecipientRegistration, checkRelayHealth, deploySubaccountForwarder, deriveSubaccountChildDepositKey, deriveSubaccountChildOwner, deriveSubaccountChildPrivateKey, deriveSubaccountSalt, deriveSubaccountSlot, deriveX402PayerAddress, deriveX402PayerKey, findNextSubaccountWithdrawNonce, getAddresses, getExtDataHash, getForwarderFactoryAddress, getMerklePath, getPoolAddress, getPrivateBalance, getQueueAddress, getQueueBalance, getRelayInfo, getRelayUrl, getSubaccountPrivateBalance, getSubaccountStatus, getX402PayerBalances, isSubaccountForwarderDeployed, isSubaccountWithdrawNonceUsed, mergeSubaccount, mergeUtxos, packEncryptedMessage, payX402Resource, poseidonHash, poseidonHash2, predictSubaccountForwarder, prepareTransaction, prove, quoteX402Resource, randomBN, selectBaseUsdcExactRequirement, selectCircuit, selectUtxosForWithdraw, shuffle, signSubaccountWithdraw, submitRelay, sweepSubaccountForwarder, toBuffer, toFixedHex, transfer, unpackEncryptedMessage, usdcAtomicToDecimalString, usdcDecimalToAtomic, withdraw };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map