javascript-solid-server 0.0.106 → 0.0.108

package/src/handlers/pay.js

@@ -35,6 +35,40 @@ import path from 'path';
 
 const DEFAULT_COST = 1; // satoshis per request
 
+// --- Chain registry for multi-chain deposits ---
+const CHAIN_REGISTRY = {
+  tbtc3: { explorer: 'https://mempool.space/testnet/api', unit: 'tbtc3', name: 'Bitcoin Testnet3' },
+  tbtc4: { explorer: 'https://mempool.space/testnet4/api', unit: 'tbtc4', name: 'Bitcoin Testnet4' },
+  btc:   { explorer: 'https://mempool.space/api', unit: 'sat', name: 'Bitcoin' },
+  ltc:   { explorer: 'https://litecoinspace.org/api', unit: 'ltc', name: 'Litecoin' },
+  signet:{ explorer: 'https://mempool.space/signet/api', unit: 'signet', name: 'Bitcoin Signet' },
+};
+
+/**
+ * Parse chain ID from a TXO URI body string.
+ * Supports: "txo:tbtc3:txid:vout", "txo:btc:txid:vout", or bare "txid:vout" (returns null).
+ */
+function parseTxoChain(body) {
+  const str = typeof body === 'string' ? body.trim() : '';
+  const match = str.match(/^txo:([a-z0-9]+):/i);
+  return match ? match[1].toLowerCase() : null;
+}
+
+// --- AMM pool storage ---
+const poolFile = () => path.join(process.env.DATA_ROOT || './data', '.well-known/webledgers/pool.json');
+
+async function loadPool() {
+  try {
+    const data = await fs.readFile(poolFile(), 'utf8');
+    return JSON.parse(data);
+  } catch { return null; }
+}
+
+async function savePool(pool) {
+  await fs.ensureDir(path.dirname(poolFile()));
+  await fs.writeFile(poolFile(), JSON.stringify(pool, null, 2));
+}
+
 // --- Replay protection ---
 const replayFile = () => path.join(process.env.DATA_ROOT || './data', '.well-known/webledgers/replay.json');
 
@@ -173,6 +207,11 @@ export function createPayHandler(options = {}) {
   const payToken = options.payToken ?? null;
   const payRate = options.payRate ?? 1;
 
+  // Parse multi-chain config: "tbtc3,tbtc4" → ['tbtc3', 'tbtc4']
+  const payChains = options.payChains
+    ? options.payChains.split(',').map(c => c.trim()).filter(c => CHAIN_REGISTRY[c])
+    : null;
+
   return async function payHandler(request, reply) {
     const url = request.url.split('?')[0];
     if (!isPayRequest(request.url)) return;
@@ -198,6 +237,10 @@ export function createPayHandler(options = {}) {
           info.token.issuer = trail.pubkeyBase ?? null;
         }
       }
+      if (payChains) {
+        info.chains = payChains.map(id => ({ id, unit: CHAIN_REGISTRY[id].unit, name: CHAIN_REGISTRY[id].name }));
+        info.pool = '/pay/.pool';
+      }
       return reply.send(info);
     }
 
@@ -209,12 +252,21 @@ export function createPayHandler(options = {}) {
       }
       const didUri = pubkeyToDidNostr(pubkey);
       const ledger = await readLedger();
-      return reply.send({
+      const response = {
         did: didUri,
         balance: getBalance(ledger, didUri),
         cost,
         unit: 'sat'
-      });
+      };
+      // Include per-chain balances when multi-chain is enabled
+      if (payChains) {
+        response.balances = {};
+        for (const chainId of payChains) {
+          const unit = CHAIN_REGISTRY[chainId].unit;
+          response.balances[unit] = getBalance(ledger, didUri, unit);
+        }
+      }
+      return reply.send(response);
     }
 
     // --- POST /pay/.deposit ---
@@ -284,21 +336,37 @@ export function createPayHandler(options = {}) {
 
       // --- Sats deposit (TXO URI) ---
       if (deposit.type === 'sats') {
-        const result = await verifySatsDeposit(deposit.txo, mempoolUrl);
+        // Detect chain from TXO URI prefix (e.g. "txo:tbtc3:txid:vout")
+        const chainId = parseTxoChain(deposit.txo);
+        let depositMempoolUrl = mempoolUrl;
+        let currency = null; // null = default (simple string format)
+
+        if (chainId && payChains && payChains.includes(chainId)) {
+          const chain = CHAIN_REGISTRY[chainId];
+          depositMempoolUrl = chain.explorer.replace(/\/api$/, '');
+          currency = chain.unit;
+        } else if (chainId && payChains) {
+          return reply.code(400).send({
+            error: `Chain '${chainId}' not enabled. Enabled chains: ${payChains.join(', ')}`,
+          });
+        }
+
+        const result = await verifySatsDeposit(deposit.txo, depositMempoolUrl);
         if (!result.valid) {
           return reply.code(400).send({ error: result.error });
         }
 
         const didUri = pubkeyToDidNostr(pubkey);
         const ledger = await readLedger();
-        const newBalance = credit(ledger, didUri, result.amount);
+        const newBalance = credit(ledger, didUri, result.amount, currency);
         await writeLedger(ledger);
 
         return reply.send({
           did: didUri,
           deposited: result.amount,
           balance: newBalance,
-          unit: 'sat'
+          unit: currency || 'sat',
+          ...(chainId ? { chain: chainId } : {})
         });
       }
 
@@ -356,13 +424,17 @@ export function createPayHandler(options = {}) {
         return reply.code(400).send({ error: 'Amount must be positive' });
       }
 
-      // Check sat balance
+      // Determine payment currency — chain-specific (e.g. "tbtc4") or generic "sat"
+      const currency = (body?.currency && payChains && payChains.includes(body.currency))
+        ? body.currency : null;
+
+      // Check balance
       const didUri = pubkeyToDidNostr(pubkey);
       const ledger = await readLedger();
-      const balance = getBalance(ledger, didUri);
+      const balance = getBalance(ledger, didUri, currency);
       if (balance < satCost) {
         return reply.code(402).send({
-          error: 'Insufficient sat balance',
+          error: `Insufficient ${currency || 'sat'} balance`,
           balance,
           cost: satCost,
           rate: payRate,
@@ -389,8 +461,8 @@ export function createPayHandler(options = {}) {
         return reply.code(500).send({ error: `Transfer failed: ${err.message}` });
       }
 
-      // Debit sats from buyer
-      debit(ledger, didUri, satCost);
+      // Debit from buyer
+      debit(ledger, didUri, satCost, currency);
       await writeLedger(ledger);
 
       return reply.send({
@@ -398,8 +470,8 @@ export function createPayHandler(options = {}) {
         ticker,
         cost: satCost,
         rate: payRate,
-        balance: getBalance(ledger, didUri),
-        unit: 'sat',
+        balance: getBalance(ledger, didUri, currency),
+        unit: currency || 'sat',
         txid: result.txid,
         proof: {
           state: result.state,
@@ -673,6 +745,237 @@ export function createPayHandler(options = {}) {
       });
     }
 
+    // --- GET /pay/.pool — AMM pool state (public) ---
+    if (url === '/pay/.pool' && request.method === 'GET') {
+      if (!payChains || payChains.length < 2) {
+        return reply.code(400).send({ error: 'AMM not configured (requires --pay-chains with 2 chains)' });
+      }
+      const pool = await loadPool();
+      if (!pool) {
+        return reply.send({
+          pair: [CHAIN_REGISTRY[payChains[0]].unit, CHAIN_REGISTRY[payChains[1]].unit],
+          reserves: { [CHAIN_REGISTRY[payChains[0]].unit]: 0, [CHAIN_REGISTRY[payChains[1]].unit]: 0 },
+          k: 0,
+          fee: 0.003,
+          totalShares: 0,
+          lpShares: {}
+        });
+      }
+      return reply.send(pool);
+    }
+
+    // --- POST /pay/.pool — AMM operations (swap, add-liquidity, remove-liquidity) ---
+    if (url === '/pay/.pool' && request.method === 'POST') {
+      if (!payChains || payChains.length < 2) {
+        return reply.code(400).send({ error: 'AMM not configured (requires --pay-chains with 2 chains)' });
+      }
+
+      const pubkey = await getNostrPubkey(request);
+      if (!pubkey) {
+        return reply.code(401).send({ error: 'NIP-98 authentication required' });
+      }
+
+      let body = request.body;
+      try {
+        if (Buffer.isBuffer(body)) body = JSON.parse(body.toString('utf8'));
+        if (typeof body === 'string') body = JSON.parse(body);
+      } catch {
+        return reply.code(400).send({ error: 'Invalid JSON body' });
+      }
+
+      const didUri = pubkeyToDidNostr(pubkey);
+      const unitA = CHAIN_REGISTRY[payChains[0]].unit;
+      const unitB = CHAIN_REGISTRY[payChains[1]].unit;
+      const action = body?.action;
+
+      // --- ADD LIQUIDITY ---
+      if (action === 'add-liquidity') {
+        const amountA = Math.floor(body?.[unitA] || 0);
+        const amountB = Math.floor(body?.[unitB] || 0);
+        if (amountA <= 0 || amountB <= 0) {
+          return reply.code(400).send({ error: `Specify ${unitA} and ${unitB} amounts` });
+        }
+
+        const ledger = await readLedger();
+        const balA = getBalance(ledger, didUri, unitA);
+        const balB = getBalance(ledger, didUri, unitB);
+        if (balA < amountA) {
+          return reply.code(402).send({ error: `Insufficient ${unitA} balance`, balance: balA, required: amountA });
+        }
+        if (balB < amountB) {
+          return reply.code(402).send({ error: `Insufficient ${unitB} balance`, balance: balB, required: amountB });
+        }
+
+        let pool = await loadPool();
+        if (!pool) {
+          pool = {
+            pair: [unitA, unitB],
+            reserves: { [unitA]: 0, [unitB]: 0 },
+            k: 0,
+            fee: 0.003,
+            totalShares: 0,
+            lpShares: {}
+          };
+        }
+
+        // Calculate LP shares (initial: shares = sqrt(amountA * amountB))
+        let newShares;
+        if (pool.totalShares === 0) {
+          newShares = Math.floor(Math.sqrt(amountA * amountB));
+        } else {
+          // Proportional: min(amountA/reserveA, amountB/reserveB) * totalShares
+          const ratioA = amountA / pool.reserves[unitA];
+          const ratioB = amountB / pool.reserves[unitB];
+          newShares = Math.floor(Math.min(ratioA, ratioB) * pool.totalShares);
+        }
+        if (newShares <= 0) {
+          return reply.code(400).send({ error: 'Amounts too small to mint LP shares' });
+        }
+
+        // Debit user balances
+        debit(ledger, didUri, amountA, unitA);
+        debit(ledger, didUri, amountB, unitB);
+        await writeLedger(ledger);
+
+        // Update pool
+        pool.reserves[unitA] += amountA;
+        pool.reserves[unitB] += amountB;
+        pool.k = pool.reserves[unitA] * pool.reserves[unitB];
+        pool.totalShares += newShares;
+        pool.lpShares[didUri] = (pool.lpShares[didUri] || 0) + newShares;
+        await savePool(pool);
+
+        return reply.send({
+          action: 'add-liquidity',
+          deposited: { [unitA]: amountA, [unitB]: amountB },
+          shares: newShares,
+          totalShares: pool.totalShares,
+          reserves: pool.reserves,
+          k: pool.k
+        });
+      }
+
+      // --- REMOVE LIQUIDITY ---
+      if (action === 'remove-liquidity') {
+        const shares = Math.floor(body?.shares || 0);
+        const pool = await loadPool();
+        if (!pool || pool.totalShares === 0) {
+          return reply.code(400).send({ error: 'Pool has no liquidity' });
+        }
+
+        const userShares = pool.lpShares[didUri] || 0;
+        const toRemove = body?.all ? userShares : shares;
+        if (toRemove <= 0 || toRemove > userShares) {
+          return reply.code(400).send({ error: 'Invalid shares', yours: userShares });
+        }
+
+        // Calculate proportional withdrawal
+        const fraction = toRemove / pool.totalShares;
+        const outA = Math.floor(pool.reserves[unitA] * fraction);
+        const outB = Math.floor(pool.reserves[unitB] * fraction);
+
+        // Credit user
+        const ledger = await readLedger();
+        credit(ledger, didUri, outA, unitA);
+        credit(ledger, didUri, outB, unitB);
+        await writeLedger(ledger);
+
+        // Update pool
+        pool.reserves[unitA] -= outA;
+        pool.reserves[unitB] -= outB;
+        pool.k = pool.reserves[unitA] * pool.reserves[unitB];
+        pool.totalShares -= toRemove;
+        pool.lpShares[didUri] -= toRemove;
+        if (pool.lpShares[didUri] <= 0) delete pool.lpShares[didUri];
+        await savePool(pool);
+
+        return reply.send({
+          action: 'remove-liquidity',
+          withdrawn: { [unitA]: outA, [unitB]: outB },
+          sharesRemoved: toRemove,
+          totalShares: pool.totalShares,
+          reserves: pool.reserves
+        });
+      }
+
+      // --- SWAP ---
+      if (action === 'swap') {
+        const sellUnit = body?.sell;
+        const amount = Math.floor(body?.amount || 0);
+        if (!sellUnit || ![unitA, unitB].includes(sellUnit)) {
+          return reply.code(400).send({ error: `Specify sell: "${unitA}" or "${unitB}"` });
+        }
+        if (amount <= 0) {
+          return reply.code(400).send({ error: 'Amount must be positive' });
+        }
+
+        const pool = await loadPool();
+        if (!pool || pool.k === 0) {
+          return reply.code(400).send({ error: 'Pool has no liquidity' });
+        }
+
+        const buyUnit = sellUnit === unitA ? unitB : unitA;
+
+        // Check user balance
+        const ledger = await readLedger();
+        const userBal = getBalance(ledger, didUri, sellUnit);
+        if (userBal < amount) {
+          return reply.code(402).send({
+            error: `Insufficient ${sellUnit} balance`,
+            balance: userBal,
+            required: amount,
+            deposit: '/pay/.deposit'
+          });
+        }
+
+        // Constant product: (reserveIn + amountIn * (1-fee)) * (reserveOut - amountOut) = k
+        const reserveIn = pool.reserves[sellUnit];
+        const reserveOut = pool.reserves[buyUnit];
+        const amountInAfterFee = amount * (1 - pool.fee);
+        const amountOut = Math.floor((reserveOut * amountInAfterFee) / (reserveIn + amountInAfterFee));
+
+        if (amountOut <= 0) {
+          return reply.code(400).send({ error: 'Trade too small' });
+        }
+
+        // Slippage protection
+        if (body?.minReceived && amountOut < body.minReceived) {
+          return reply.code(400).send({
+            error: 'Slippage exceeded',
+            wouldReceive: amountOut,
+            minReceived: body.minReceived
+          });
+        }
+
+        // Execute: debit sellUnit, credit buyUnit
+        debit(ledger, didUri, amount, sellUnit);
+        credit(ledger, didUri, amountOut, buyUnit);
+        await writeLedger(ledger);
+
+        // Update pool reserves
+        pool.reserves[sellUnit] += amount;
+        pool.reserves[buyUnit] -= amountOut;
+        pool.k = pool.reserves[unitA] * pool.reserves[unitB];
+        await savePool(pool);
+
+        const price = amount / amountOut;
+        return reply.send({
+          action: 'swap',
+          sold: { unit: sellUnit, amount },
+          bought: { unit: buyUnit, amount: amountOut },
+          price: Math.round(price * 10000) / 10000,
+          fee: Math.floor(amount * pool.fee),
+          reserves: pool.reserves,
+          balances: {
+            [sellUnit]: getBalance(ledger, didUri, sellUnit),
+            [buyUnit]: getBalance(ledger, didUri, buyUnit)
+          }
+        });
+      }
+
+      return reply.code(400).send({ error: 'Unknown action. Use: swap, add-liquidity, remove-liquidity' });
+    }
+
     // --- GET/HEAD /pay/* — paid resource access ---
     if (request.method === 'GET' || request.method === 'HEAD') {
       const pubkey = await getNostrPubkey(request);
@@ -685,21 +988,41 @@ export function createPayHandler(options = {}) {
 
       const didUri = pubkeyToDidNostr(pubkey);
       const ledger = await readLedger();
-      const { success, balance } = debit(ledger, didUri, cost);
 
-      if (!success) {
-        return reply.code(402).send({
+      // Try generic sat balance first, then fall back to chain balances
+      const currency = request.headers['x-pay-currency'] || null;
+      let payUnit = currency && payChains && payChains.includes(currency) ? currency : null;
+      let result = debit(ledger, didUri, cost, payUnit);
+
+      // If generic sat failed and no explicit currency, try each chain balance
+      if (!result.success && !payUnit && payChains) {
+        for (const chainId of payChains) {
+          result = debit(ledger, didUri, cost, chainId);
+          if (result.success) { payUnit = chainId; break; }
+        }
+      }
+
+      if (!result.success) {
+        const response = {
           error: 'Payment Required',
-          balance,
+          balance: result.balance,
           cost,
           unit: 'sat',
           deposit: '/pay/.deposit'
-        });
+        };
+        if (payChains) {
+          response.balances = {};
+          for (const chainId of payChains) {
+            response.balances[chainId] = getBalance(ledger, didUri, chainId);
+          }
+        }
+        return reply.code(402).send(response);
       }
 
       await writeLedger(ledger);
-      reply.header('X-Balance', String(balance));
+      reply.header('X-Balance', String(result.balance));
       reply.header('X-Cost', String(cost));
+      if (payUnit) reply.header('X-Pay-Currency', payUnit);
       return; // continue to normal resource handler
     }
 

package/src/server.js

@@ -18,6 +18,7 @@ import { createPayHandler, isPayRequest } from './handlers/pay.js';
 import { activityPubPlugin, getActorHandler } from './ap/index.js';
 import { remoteStoragePlugin } from './remotestorage.js';
 import { dbPlugin } from './db/index.js';
+import { webrtcPlugin } from './webrtc/index.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -74,6 +75,9 @@ export function createServer(options = {}) {
   const nostrEnabled = options.nostr ?? false;
   const nostrPath = options.nostrPath ?? '/relay';
   const nostrMaxEvents = options.nostrMaxEvents ?? 1000;
+  // WebRTC signaling is OFF by default
+  const webrtcEnabled = options.webrtc ?? false;
+  const webrtcPath = options.webrtcPath ?? '/.webrtc';
   // ActivityPub federation is OFF by default
   const activitypubEnabled = options.activitypub ?? false;
   const apUsername = options.apUsername ?? 'me';
@@ -102,6 +106,7 @@ export function createServer(options = {}) {
   const payAddress = options.payAddress ?? null; // Pod's MRC20 address for token deposits
   const payToken = options.payToken ?? null; // Token ticker for primary market
   const payRate = options.payRate ?? 1; // Sats per token
+  const payChains = options.payChains ?? null; // Multi-chain IDs (e.g. "tbtc3,tbtc4")
 
   // Set data root via environment variable if provided
   if (options.root) {
@@ -239,6 +244,11 @@ export function createServer(options = {}) {
     });
   }
 
+  // Register WebRTC signaling if enabled
+  if (webrtcEnabled) {
+    fastify.register(webrtcPlugin, { path: webrtcPath });
+  }
+
   // Register ActivityPub plugin if enabled
   if (activitypubEnabled) {
     fastify.register(activityPubPlugin, {
@@ -330,6 +340,12 @@ export function createServer(options = {}) {
       return;
     }
 
+    // Allow WebRTC signaling endpoint through when enabled
+    const urlNoQuery = request.url.split('?')[0];
+    if (webrtcEnabled && urlNoQuery === webrtcPath) {
+      return;
+    }
+
     const segments = request.url.split('/').map(s => s.split('?')[0]); // Remove query strings
     const hasForbiddenDotfile = segments.some(seg =>
       seg.startsWith('.') &&
@@ -376,7 +392,7 @@ export function createServer(options = {}) {
 
   // HTTP 402 Payment Required handler for /pay/* routes
   if (payEnabled) {
-    fastify.addHook('preHandler', createPayHandler({ cost: payCost, mempoolUrl: payMempoolUrl, payAddress, payToken, payRate }));
+    fastify.addHook('preHandler', createPayHandler({ cost: payCost, mempoolUrl: payMempoolUrl, payAddress, payToken, payRate, payChains }));
   }
 
   // Authorization hook - check WAC permissions
@@ -404,6 +420,7 @@ export function createServer(options = {}) {
         request.url.startsWith('/storage/') ||
         (payEnabled && isPayRequest(request.url)) ||
         (mongoEnabled && (request.url === '/db' || request.url.startsWith('/db/'))) ||
+        (webrtcEnabled && (request.url === webrtcPath || request.url.startsWith(webrtcPath + '?'))) ||
         mashlibPaths.some(p => request.url === p || request.url.startsWith(p + '.'))) {
       return;
     }

package/src/webledger.js

@@ -77,16 +77,21 @@ export async function writeLedger(ledger, ledgerPath = DEFAULT_PATH) {
  * Get balance for a URI
  * @param {object} ledger - WebLedger object
  * @param {string} uri - Agent URI (e.g. did:nostr:...)
+ * @param {string} [currency] - Currency code (e.g. 'tbtc3', 'tbtc4'). If omitted, reads default/simple amount.
  * @returns {number} Balance as integer
  */
-export function getBalance(ledger, uri) {
+export function getBalance(ledger, uri, currency) {
   const entry = ledger.entries.find(e => e.url === uri);
   if (!entry) return 0;
-  // Handle both simple string and array amount formats
+  // Handle array amount format
   if (Array.isArray(entry.amount)) {
-    const sat = entry.amount.find(a => a.currency === 'satoshi' || a.currency === 'sat');
-    return sat ? parseInt(sat.value, 10) || 0 : 0;
+    const target = currency
+      ? entry.amount.find(a => a.currency === currency)
+      : entry.amount.find(a => a.currency === 'satoshi' || a.currency === 'sat');
+    return target ? parseInt(target.value, 10) || 0 : 0;
   }
+  // Simple string format — only if no specific currency requested, or currency matches default
+  if (currency) return 0;
   return parseInt(entry.amount, 10) || 0;
 }
 
@@ -95,13 +100,34 @@ export function getBalance(ledger, uri) {
  * @param {object} ledger - WebLedger object
  * @param {string} uri - Agent URI
  * @param {number} amount - New balance
+ * @param {string} [currency] - Currency code. If provided, uses array amount format.
  */
-export function setBalance(ledger, uri, amount) {
-  const entry = ledger.entries.find(e => e.url === uri);
-  if (entry) {
-    entry.amount = String(amount);
+export function setBalance(ledger, uri, amount, currency) {
+  let entry = ledger.entries.find(e => e.url === uri);
+  if (!currency) {
+    // Simple string format (backward compatible)
+    if (entry) {
+      entry.amount = String(amount);
+    } else {
+      ledger.entries.push({ type: 'Entry', url: uri, amount: String(amount) });
+    }
+    return;
+  }
+  // Multi-currency: use array format
+  if (!entry) {
+    entry = { type: 'Entry', url: uri, amount: [] };
+    ledger.entries.push(entry);
+  }
+  // Migrate simple string to array if needed
+  if (!Array.isArray(entry.amount)) {
+    const oldVal = parseInt(entry.amount, 10) || 0;
+    entry.amount = oldVal > 0 ? [{ currency: 'satoshi', value: String(oldVal) }] : [];
+  }
+  const existing = entry.amount.find(a => a.currency === currency);
+  if (existing) {
+    existing.value = String(amount);
   } else {
-    ledger.entries.push({ type: 'Entry', url: uri, amount: String(amount) });
+    entry.amount.push({ currency, value: String(amount) });
   }
 }
 
@@ -110,12 +136,13 @@ export function setBalance(ledger, uri, amount) {
  * @param {object} ledger - WebLedger object
  * @param {string} uri - Agent URI
  * @param {number} amount - Amount to add
+ * @param {string} [currency] - Currency code
  * @returns {number} New balance
  */
-export function credit(ledger, uri, amount) {
-  const current = getBalance(ledger, uri);
+export function credit(ledger, uri, amount, currency) {
+  const current = getBalance(ledger, uri, currency);
   const newBalance = current + amount;
-  setBalance(ledger, uri, newBalance);
+  setBalance(ledger, uri, newBalance, currency);
   return newBalance;
 }
 
@@ -124,15 +151,16 @@ export function credit(ledger, uri, amount) {
  * @param {object} ledger - WebLedger object
  * @param {string} uri - Agent URI
  * @param {number} amount - Amount to subtract
+ * @param {string} [currency] - Currency code
  * @returns {{success: boolean, balance: number}} Result
  */
-export function debit(ledger, uri, amount) {
-  const current = getBalance(ledger, uri);
+export function debit(ledger, uri, amount, currency) {
+  const current = getBalance(ledger, uri, currency);
   if (current < amount) {
     return { success: false, balance: current };
   }
   const newBalance = current - amount;
-  setBalance(ledger, uri, newBalance);
+  setBalance(ledger, uri, newBalance, currency);
   return { success: true, balance: newBalance };
 }