@veil-cash/sdk 0.6.1 → 0.6.2

package/dist/index.cjs

@@ -1669,7 +1669,16 @@ async function postRelayJson(endpoint, body, relayUrl) {
     },
     body: JSON.stringify(body)
   });
-  const data = await response.json();
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch {
+    throw new RelayError(
+      `Relay returned non-JSON response (HTTP ${response.status})`,
+      response.status
+    );
+  }
   if (!response.ok) {
     const errorData = data;
     throw new RelayError(
@@ -2241,11 +2250,12 @@ function deriveSubaccountChildDepositKey(childPrivateKey) {
 }
 async function predictSubaccountForwarder(options) {
   const publicClient = createBaseClient(options.rpcUrl);
+  const depositKeyBytes = options.childDepositKey.startsWith("0x") ? options.childDepositKey : `0x${options.childDepositKey}`;
   return publicClient.readContract({
     abi: FORWARDER_FACTORY_ABI,
     address: getForwarderFactoryAddress(),
     functionName: "computeAddress",
-    args: [options.salt, options.childDepositKey, options.childOwner]
+    args: [options.salt, depositKeyBytes, options.childOwner]
   });
 }
 async function deriveSubaccountSlot(options) {
@@ -2282,7 +2292,7 @@ async function deploySubaccountForwarder(options) {
     slot: options.slot,
     rpcUrl: options.rpcUrl
   });
-  return postRelayJson(
+  const result = await postRelayJson(
     "/stealth/deploy",
     {
       salt: slot.salt,
@@ -2292,6 +2302,7 @@ async function deploySubaccountForwarder(options) {
     },
     options.relayUrl
   );
+  return { ...result, slot };
 }
 async function sweepSubaccountForwarder(options) {
   const asset = normalizeAsset(options.asset);
@@ -2316,11 +2327,32 @@ function toQueueStatus(asset, result) {
     pendingDeposits: result.pendingDeposits
   };
 }
+function toPrivateBalanceStatus(result) {
+  return {
+    privateBalance: result.privateBalance,
+    privateBalanceWei: result.privateBalanceWei,
+    utxoCount: result.utxoCount,
+    spentCount: result.spentCount,
+    unspentCount: result.unspentCount
+  };
+}
+async function getSubaccountPrivateBalance(options) {
+  const normalizedSlot = normalizeSlot(options.slot);
+  assertPrivateKey(options.rootPrivateKey, "rootPrivateKey");
+  const childPrivateKey = deriveSubaccountChildPrivateKey(options.rootPrivateKey, normalizedSlot);
+  const childKeypair = new Keypair(childPrivateKey);
+  return getPrivateBalance({
+    keypair: childKeypair,
+    pool: options.pool,
+    rpcUrl: options.rpcUrl,
+    onProgress: options.onProgress
+  });
+}
 async function getSubaccountStatus(options) {
   const slot = await deriveSubaccountSlot(options);
   const publicClient = createBaseClient(options.rpcUrl);
   const addresses = getAddresses();
-  const [deployed, ethWei, usdcWei, ethQueue, usdcQueue] = await Promise.all([
+  const [deployed, ethWei, usdcWei, ethQueue, usdcQueue, ethPrivate, usdcPrivate] = await Promise.all([
     isSubaccountForwarderDeployed({
       forwarderAddress: slot.forwarderAddress,
       rpcUrl: options.rpcUrl
@@ -2341,6 +2373,18 @@ async function getSubaccountStatus(options) {
       address: slot.forwarderAddress,
       pool: "usdc",
       rpcUrl: options.rpcUrl
+    }),
+    getSubaccountPrivateBalance({
+      rootPrivateKey: options.rootPrivateKey,
+      slot: options.slot,
+      pool: "eth",
+      rpcUrl: options.rpcUrl
+    }),
+    getSubaccountPrivateBalance({
+      rootPrivateKey: options.rootPrivateKey,
+      slot: options.slot,
+      pool: "usdc",
+      rpcUrl: options.rpcUrl
     })
   ]);
   return {
@@ -2356,6 +2400,10 @@ async function getSubaccountStatus(options) {
         balanceWei: usdcWei.toString()
       }
     },
+    privateBalances: {
+      eth: toPrivateBalanceStatus(ethPrivate),
+      usdc: toPrivateBalanceStatus(usdcPrivate)
+    },
     queues: {
       eth: toQueueStatus("eth", ethQueue),
       usdc: toQueueStatus("usdc", usdcQueue)
@@ -2502,6 +2550,137 @@ async function buildSubaccountRecoveryTx(options) {
     signature
   };
 }
+async function mergeSubaccount(options) {
+  const {
+    rootPrivateKey,
+    slot,
+    pool = "eth",
+    rpcUrl,
+    relayUrl,
+    onProgress
+  } = options;
+  const normalizedSlot = normalizeSlot(slot);
+  assertPrivateKey(rootPrivateKey, "rootPrivateKey");
+  const poolConfig = POOL_CONFIG[pool];
+  const poolAddress = getPoolAddress(pool);
+  const childPrivateKey = deriveSubaccountChildPrivateKey(rootPrivateKey, normalizedSlot);
+  const childKeypair = new Keypair(childPrivateKey);
+  const parentKeypair = new Keypair(rootPrivateKey);
+  onProgress?.("Fetching subaccount balance...");
+  const balanceResult = await getPrivateBalance({
+    keypair: childKeypair,
+    pool,
+    rpcUrl,
+    onProgress
+  });
+  const unspentUtxoInfos = balanceResult.utxos.filter((u) => !u.isSpent);
+  if (unspentUtxoInfos.length === 0) {
+    throw new Error("Subaccount has no unspent UTXOs to merge");
+  }
+  if (unspentUtxoInfos.length > 16) {
+    throw new Error(
+      `Subaccount has ${unspentUtxoInfos.length} unspent UTXOs which exceeds the 16-input circuit limit. Consolidate UTXOs on the subaccount first before merging.`
+    );
+  }
+  onProgress?.("Preparing UTXOs...");
+  const publicClient = viem.createPublicClient({
+    chain: chains.base,
+    transport: viem.http(rpcUrl)
+  });
+  const utxos = [];
+  for (const utxoInfo of unspentUtxoInfos) {
+    const encryptedOutputs = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getEncryptedOutputs",
+      args: [BigInt(utxoInfo.index), BigInt(utxoInfo.index + 1)]
+    });
+    if (encryptedOutputs.length > 0) {
+      try {
+        const utxo = Utxo.decrypt(encryptedOutputs[0], childKeypair);
+        utxo.index = utxoInfo.index;
+        utxos.push(utxo);
+      } catch {
+      }
+    }
+  }
+  if (utxos.length === 0) {
+    throw new Error("Failed to decrypt subaccount UTXOs");
+  }
+  onProgress?.("Selecting UTXOs...");
+  const amount = balanceResult.privateBalance;
+  const { selectedUtxos, changeAmount } = selectUtxosForWithdraw(
+    utxos,
+    amount,
+    poolConfig.decimals
+  );
+  const outputs = [];
+  const mergeWei = viem.parseUnits(amount, poolConfig.decimals);
+  outputs.push(new Utxo({ amount: mergeWei, keypair: parentKeypair }));
+  if (changeAmount > 0n) {
+    outputs.push(new Utxo({ amount: changeAmount, keypair: parentKeypair }));
+  }
+  onProgress?.("Fetching commitments...");
+  const nextIndex = await publicClient.readContract({
+    address: poolAddress,
+    abi: POOL_ABI,
+    functionName: "nextIndex"
+  });
+  const BATCH_SIZE = 5e3;
+  const commitments = [];
+  const totalBatches = Math.ceil(nextIndex / BATCH_SIZE);
+  for (let start = 0; start < nextIndex; start += BATCH_SIZE) {
+    const end = Math.min(start + BATCH_SIZE, nextIndex);
+    const batchNum = Math.floor(start / BATCH_SIZE) + 1;
+    onProgress?.("Fetching commitments", `batch ${batchNum}/${totalBatches}`);
+    const batch = await publicClient.readContract({
+      address: poolAddress,
+      abi: POOL_ABI,
+      functionName: "getCommitments",
+      args: [BigInt(start), BigInt(end)]
+    });
+    commitments.push(...batch.map((c) => c.toString()));
+  }
+  onProgress?.("Building ZK proof...");
+  const result = await prepareTransaction({
+    commitments,
+    inputs: selectedUtxos,
+    outputs,
+    fee: 0,
+    recipient: "0x0000000000000000000000000000000000000000",
+    relayer: "0x0000000000000000000000000000000000000000",
+    onProgress
+  });
+  onProgress?.("Submitting to relay...");
+  const relayResult = await submitRelay({
+    type: "transfer",
+    pool,
+    relayUrl,
+    proofArgs: {
+      proof: result.args.proof,
+      root: result.args.root,
+      inputNullifiers: result.args.inputNullifiers,
+      outputCommitments: result.args.outputCommitments,
+      publicAmount: result.args.publicAmount,
+      extDataHash: result.args.extDataHash
+    },
+    extData: result.extData,
+    metadata: {
+      amount,
+      recipient: "self",
+      inputUtxoCount: selectedUtxos.length,
+      outputUtxoCount: outputs.length
+    }
+  });
+  return {
+    success: relayResult.success,
+    transactionHash: relayResult.transactionHash,
+    blockNumber: relayResult.blockNumber,
+    amount,
+    slot: normalizedSlot,
+    pool
+  };
+}
 
 exports.ADDRESSES = ADDRESSES;
 exports.CIRCUIT_CONFIG = CIRCUIT_CONFIG;
@@ -2550,9 +2729,11 @@ exports.getQueueAddress = getQueueAddress;
 exports.getQueueBalance = getQueueBalance;
 exports.getRelayInfo = getRelayInfo;
 exports.getRelayUrl = getRelayUrl;
+exports.getSubaccountPrivateBalance = getSubaccountPrivateBalance;
 exports.getSubaccountStatus = getSubaccountStatus;
 exports.isSubaccountForwarderDeployed = isSubaccountForwarderDeployed;
 exports.isSubaccountWithdrawNonceUsed = isSubaccountWithdrawNonceUsed;
+exports.mergeSubaccount = mergeSubaccount;
 exports.mergeUtxos = mergeUtxos;
 exports.packEncryptedMessage = packEncryptedMessage;
 exports.poseidonHash = poseidonHash;