fix: e2e scenario sat leaks + sweep via HTTP API (WIP)

- Scenario 11: add abort after nosend test (was locking A's main UTXO)
- Scenario 10: B internalizes concurrent sends (were lost on chain)
- Scenario 7: note signAction returns raw tx not BEEF (can't internalize)
- Sweep: use HTTP API for full balance across all baskets
- FUNDER_DIR: support env var override

Known remaining: scenario 7 loses 3K (signAction limitation),
e2e harness needs full offline audit before next run.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: Calgooon

tests/e2e/lib/setup.js

@@ -82,49 +82,52 @@ async function fundWallet(wallet, satoshis) {
  * as possible. This prevents losing sats when a scenario creates unspendable outputs.
  */
 async function sweepToFunder(wallet) {
-  const balance = parseInt(
-    execSync(`cd "${wallet.dir}" && "${BSV}" balance`, { encoding: 'utf-8' }).trim(),
-  );
+  // Use HTTP API for full balance (covers all baskets)
+  const balance = await wallet.client.balance();
 
   if (balance < 600) {
     console.log(`  ${wallet.client.name}: ${balance} sats (dust, skipping sweep)`);
     return 0;
   }
 
-  const funderAddr = execSync(
-    `cd "${FUNDER_DIR}" && "${BSV}" address`, { encoding: 'utf-8' },
-  ).trim();
+  // Get funder's receiving key via HTTP API
+  const funderClient = new WalletClient(FUNDER_PORT, 'funder');
+  const funderKey = await funderClient.getPublicKey(
+    [2, '3241645161d8'], 'SfKxPIJNgdI= NaGLC6fMH50=', ANYONE_KEY, true,
+  );
+  const funderScript = buildP2PKH(funderKey.publicKey);
 
-  // Try full sweep first, then halve on failure to recover what we can
   let sweepAmount = balance - 300; // leave room for fee
   let swept = 0;
 
   for (let attempt = 0; attempt < 4 && sweepAmount >= 600; attempt++) {
     try {
-      const rawResult = execSync(
-        `cd "${wallet.dir}" && "${BSV}" --json send "${funderAddr}" ${sweepAmount}`,
-        { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] },
-      ).trim();
-
-      const parsed = JSON.parse(extractJson(rawResult));
-
-      // Funder internalizes directly
-      execSync(
-        `cd "${FUNDER_DIR}" && "${BSV}" fund "${parsed.beef}" --vout 0`,
-        { stdio: ['pipe', 'pipe', 'pipe'] },
+      const result = await wallet.client.createAction(
+        [{ lockingScript: funderScript, satoshis: sweepAmount, outputDescription: 'sweep to funder' }],
+        `sweep ${sweepAmount} sats back to funder`,
       );
 
+      // Funder internalizes the BEEF
+      await funderClient.internalizeAction(result.tx, [{
+        outputIndex: 0,
+        protocol: 'wallet payment',
+        paymentRemittance: {
+          derivationPrefix: 'SfKxPIJNgdI=',
+          derivationSuffix: 'NaGLC6fMH50=',
+          senderIdentityKey: ANYONE_KEY,
+        },
+      }], `sweep from ${wallet.client.name}`);
+
       console.log(`  ${wallet.client.name}: swept ${sweepAmount} sats back to funder`);
       swept += sweepAmount;
       break;
     } catch (e) {
       if (attempt < 3) {
-        // Halve the amount and retry — some UTXOs may be unspendable
         const prev = sweepAmount;
         sweepAmount = Math.floor(sweepAmount / 2);
-        console.log(`  ${wallet.client.name}: sweep ${prev} failed, retrying with ${sweepAmount}`);
+        console.log(`  ${wallet.client.name}: sweep ${prev} failed (${e.message.slice(0, 60)}), retrying with ${sweepAmount}`);
       } else {
-        console.log(`  WARNING: ${wallet.client.name}: could not sweep (${sweepAmount} sats stuck)`);
+        console.log(`  WARNING: ${wallet.client.name}: could not sweep (${sweepAmount} sats stuck: ${e.message.slice(0, 80)})`);
       }
     }
   }

tests/e2e/scenarios/07-unsigned-action.js

@@ -49,6 +49,10 @@ module.exports = {
       : signed.txid;
     assert(txidHex.length === 64, `txid hex must be 64 chars, got ${txidHex.length}`);
 
+    // Note: signAction returns raw tx, not BEEF — can't internalize in B.
+    // The 3K sats go to B's address on chain but B can't track them.
+    // This is a known limitation of the deferred signing flow.
+
     // WoC audit (quick check, don't block on chained unconfirmed)
     let wocOk = false;
     try {

tests/e2e/scenarios/10-concurrent-sends.js

@@ -35,7 +35,7 @@ module.exports = {
           outputDescription: `Concurrent send #${i + 1} of ${concurrency}`,
           tags: ['e2e-concurrent'],
         }], `E2E.4: concurrent #${i + 1}`)
-          .then(r => ({ status: 'ok', txid: r.txid, index: i }))
+          .then(r => ({ status: 'ok', txid: r.txid, tx: r.tx, index: i }))
           .catch(e => ({ status: 'error', error: e.message, index: i }))
       );
     }
@@ -65,11 +65,19 @@ module.exports = {
     assert(txids.size === concurrency,
       `All ${concurrency} txids must be unique, got ${txids.size}`);
 
-    // B internalizes all (using direct BEEF from responses)
-    let internalized = 0;
+    // B internalizes all (so sats can be swept back)
     for (const r of succeeded) {
-      // Re-fetch the full result to get tx bytes (our concurrent results may not have full data)
-      // Actually the results should already have tx bytes from createAction
+      if (r.tx && r.tx.length > 0) {
+        await walletB.client.internalizeAction(r.tx, [{
+          outputIndex: 0,
+          protocol: 'wallet payment',
+          paymentRemittance: {
+            derivationPrefix: 'SfKxPIJNgdI=',
+            derivationSuffix: 'NaGLC6fMH50=',
+            senderIdentityKey: ANYONE_KEY,
+          },
+        }], `internalize concurrent send #${r.index + 1}`);
+      }
     }
 
     // Check balances

tests/e2e/scenarios/11-nosend-flow.js

@@ -57,6 +57,10 @@ module.exports = {
     );
     assert(internalized.accepted === true, 'B must accept the noSend tx');
 
+    // Abort the nosend tx to release A's locked UTXOs — don't leave the wallet dirty
+    const nosendRef = result.reference || result.txid;
+    await walletA.client.post('abortAction', { reference: nosendRef });
+
     return { txid: result.txid, wocConfirmed: 'n/a (noSend)', sats: amount };
   },
 };