javascript-solid-server 0.0.105 → 0.0.107

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 };
 }
 

package/test/pay.test.js

@@ -205,6 +205,492 @@ describe('HTTP 402 Pay Middleware', () => {
     });
   });
 
+  describe('GET /pay/.info', () => {
+    it('should return info without auth', async () => {
+      const res = await fetch(`${getBaseUrl()}/pay/.info`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.strictEqual(body.cost, 10);
+      assert.strictEqual(body.unit, 'sat');
+      assert.strictEqual(body.deposit, '/pay/.deposit');
+      assert.strictEqual(body.balance, '/pay/.balance');
+    });
+
+    it('should not include token info when payToken not configured', async () => {
+      const res = await fetch(`${getBaseUrl()}/pay/.info`);
+      const body = await res.json();
+      assert.strictEqual(body.token, undefined);
+    });
+  });
+
+  describe('POST /pay/.buy', () => {
+    it('should return 401 without auth', async () => {
+      const url = `${getBaseUrl()}/pay/.buy`;
+      const res = await fetch(url, { method: 'POST', body: '{"amount":10}' });
+      assertStatus(res, 401);
+    });
+
+    it('should return 400 when payToken not configured', async () => {
+      const url = `${getBaseUrl()}/pay/.buy`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': createNip98Header(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ amount: 10 })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('not configured'));
+    });
+  });
+
+  describe('POST /pay/.withdraw', () => {
+    it('should return 401 without auth', async () => {
+      const url = `${getBaseUrl()}/pay/.withdraw`;
+      const res = await fetch(url, { method: 'POST', body: '{"all":true}' });
+      assertStatus(res, 401);
+    });
+
+    it('should return 400 when payToken not configured', async () => {
+      const url = `${getBaseUrl()}/pay/.withdraw`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': createNip98Header(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ all: true })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('not configured'));
+    });
+  });
+
+  describe('Pay with token configured', () => {
+    let tokenServer;
+    let tokenUrl;
+    const tokenPrivkey = crypto.randomBytes(32);
+    const tokenPubkey = Buffer.from(schnorr.getPublicKey(tokenPrivkey)).toString('hex');
+
+    function tokenNip98(url, method = 'GET') {
+      const event = {
+        pubkey: tokenPubkey,
+        created_at: Math.floor(Date.now() / 1000),
+        kind: 27235,
+        tags: [['u', url], ['method', method]],
+        content: ''
+      };
+      const serialized = JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]);
+      event.id = crypto.createHash('sha256').update(serialized).digest('hex');
+      event.sig = Buffer.from(schnorr.sign(event.id, tokenPrivkey)).toString('hex');
+      return `Nostr ${Buffer.from(JSON.stringify(event)).toString('base64')}`;
+    }
+
+    before(async () => {
+      const { createServer } = await import('../src/server.js');
+      tokenServer = createServer({
+        logger: false,
+        forceCloseConnections: true,
+        pay: true,
+        payCost: 5,
+        payAddress: 'test-addr',
+        payToken: 'TEST',
+        payRate: 10
+      });
+      await tokenServer.listen({ port: 0, host: '127.0.0.1' });
+      const addr = tokenServer.server.address();
+      tokenUrl = `http://127.0.0.1:${addr.port}`;
+    });
+
+    after(async () => {
+      if (tokenServer) await tokenServer.close();
+    });
+
+    it('GET /pay/.info should include token info', async () => {
+      const res = await fetch(`${tokenUrl}/pay/.info`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.strictEqual(body.cost, 5);
+      assert.strictEqual(body.token.ticker, 'TEST');
+      assert.strictEqual(body.token.rate, 10);
+      assert.strictEqual(body.token.buy, '/pay/.buy');
+      assert.strictEqual(body.token.withdraw, '/pay/.withdraw');
+    });
+
+    it('POST /pay/.buy should return 402 with zero balance', async () => {
+      const url = `${tokenUrl}/pay/.buy`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ amount: 10 })
+      });
+      assertStatus(res, 402);
+      const body = await res.json();
+      assert.strictEqual(body.error, 'Insufficient sat balance');
+      assert.strictEqual(body.balance, 0);
+      assert.strictEqual(body.cost, 100); // 10 tokens * rate 10
+      assert.strictEqual(body.rate, 10);
+    });
+
+    it('POST /pay/.buy should reject wrong ticker', async () => {
+      const url = `${tokenUrl}/pay/.buy`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ ticker: 'WRONG', amount: 10 })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('only sells TEST'));
+    });
+
+    it('POST /pay/.buy should reject malformed JSON', async () => {
+      const url = `${tokenUrl}/pay/.buy`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: '{not valid json'
+      });
+      assertStatus(res, 400);
+    });
+
+    it('POST /pay/.buy should reject missing amount', async () => {
+      const url = `${tokenUrl}/pay/.buy`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Specify'));
+    });
+
+    it('POST /pay/.withdraw should return 400 with zero balance and all:true', async () => {
+      const url = `${tokenUrl}/pay/.withdraw`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ all: true })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Nothing to withdraw'));
+    });
+
+    it('POST /pay/.withdraw should return 402 when balance insufficient', async () => {
+      const url = `${tokenUrl}/pay/.withdraw`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ tokens: 1000 })
+      });
+      assertStatus(res, 402);
+      const body = await res.json();
+      assert.strictEqual(body.error, 'Insufficient balance');
+    });
+
+    it('POST /pay/.withdraw should reject malformed JSON', async () => {
+      const url = `${tokenUrl}/pay/.withdraw`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: '{bad json'
+      });
+      assertStatus(res, 400);
+    });
+
+    it('POST /pay/.withdraw should reject missing params', async () => {
+      const url = `${tokenUrl}/pay/.withdraw`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Specify'));
+    });
+
+    it('POST /pay/.sell should reject missing amount/price', async () => {
+      const url = `${tokenUrl}/pay/.sell`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Specify'));
+    });
+
+    it('POST /pay/.swap should reject missing offer id', async () => {
+      const url = `${tokenUrl}/pay/.swap`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({})
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Specify offer id'));
+    });
+
+    it('POST /pay/.swap should return 404 for unknown offer', async () => {
+      const url = `${tokenUrl}/pay/.swap`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': tokenNip98(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ id: 'nonexistent' })
+      });
+      assertStatus(res, 404);
+    });
+
+    it('GET /pay/.offers should return empty list', async () => {
+      const res = await fetch(`${tokenUrl}/pay/.offers`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.ok(Array.isArray(body));
+    });
+  });
+
+  describe('GET /pay/.offers', () => {
+    it('should return empty list without auth', async () => {
+      const res = await fetch(`${getBaseUrl()}/pay/.offers`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.ok(Array.isArray(body));
+      assert.strictEqual(body.length, 0);
+    });
+  });
+
+  describe('POST /pay/.sell', () => {
+    it('should return 401 without auth', async () => {
+      const url = `${getBaseUrl()}/pay/.sell`;
+      const res = await fetch(url, { method: 'POST', body: '{}' });
+      assertStatus(res, 401);
+    });
+
+    it('should return 400 when payToken not configured', async () => {
+      const url = `${getBaseUrl()}/pay/.sell`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': createNip98Header(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ amount: 10, price: 100 })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('not configured'));
+    });
+  });
+
+  describe('POST /pay/.swap', () => {
+    it('should return 401 without auth', async () => {
+      const url = `${getBaseUrl()}/pay/.swap`;
+      const res = await fetch(url, { method: 'POST', body: '{}' });
+      assertStatus(res, 401);
+    });
+
+    it('should return 400 when payToken not configured', async () => {
+      const url = `${getBaseUrl()}/pay/.swap`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': createNip98Header(url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ id: 'test-id' })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('not configured'));
+    });
+  });
+
+  describe('AMM with multi-chain', () => {
+    let ammServer;
+    let ammUrl;
+    const ammPrivkey = crypto.randomBytes(32);
+    const ammPubkey = Buffer.from(schnorr.getPublicKey(ammPrivkey)).toString('hex');
+    const ammPrivkey2 = crypto.randomBytes(32);
+    const ammPubkey2 = Buffer.from(schnorr.getPublicKey(ammPrivkey2)).toString('hex');
+
+    function ammNip98(pk, url, method = 'GET') {
+      const event = {
+        pubkey: Buffer.from(schnorr.getPublicKey(pk)).toString('hex'),
+        created_at: Math.floor(Date.now() / 1000),
+        kind: 27235,
+        tags: [['u', url], ['method', method]],
+        content: ''
+      };
+      const serialized = JSON.stringify([0, event.pubkey, event.created_at, event.kind, event.tags, event.content]);
+      event.id = crypto.createHash('sha256').update(serialized).digest('hex');
+      event.sig = Buffer.from(schnorr.sign(event.id, pk)).toString('hex');
+      return `Nostr ${Buffer.from(JSON.stringify(event)).toString('base64')}`;
+    }
+
+    before(async () => {
+      const { createServer } = await import('../src/server.js');
+      ammServer = createServer({
+        logger: false,
+        forceCloseConnections: true,
+        pay: true,
+        payCost: 1,
+        payChains: 'tbtc3,tbtc4'
+      });
+      await ammServer.listen({ port: 0, host: '127.0.0.1' });
+      const addr = ammServer.server.address();
+      ammUrl = `http://127.0.0.1:${addr.port}`;
+    });
+
+    after(async () => {
+      if (ammServer) await ammServer.close();
+    });
+
+    it('GET /pay/.info should include chains and pool', async () => {
+      const res = await fetch(`${ammUrl}/pay/.info`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.ok(body.chains);
+      assert.strictEqual(body.chains.length, 2);
+      assert.strictEqual(body.chains[0].id, 'tbtc3');
+      assert.strictEqual(body.chains[1].id, 'tbtc4');
+      assert.strictEqual(body.pool, '/pay/.pool');
+    });
+
+    it('GET /pay/.pool should return empty pool', async () => {
+      const res = await fetch(`${ammUrl}/pay/.pool`);
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.strictEqual(body.reserves.tbtc3, 0);
+      assert.strictEqual(body.reserves.tbtc4, 0);
+      assert.strictEqual(body.k, 0);
+      assert.strictEqual(body.totalShares, 0);
+    });
+
+    it('GET /pay/.balance should include per-chain balances', async () => {
+      const url = `${ammUrl}/pay/.balance`;
+      const res = await fetch(url, {
+        headers: { 'Authorization': ammNip98(ammPrivkey, url) }
+      });
+      assertStatus(res, 200);
+      const body = await res.json();
+      assert.ok(body.balances);
+      assert.strictEqual(body.balances.tbtc3, 0);
+      assert.strictEqual(body.balances.tbtc4, 0);
+    });
+
+    it('POST /pay/.pool swap should fail with no liquidity', async () => {
+      const url = `${ammUrl}/pay/.pool`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': ammNip98(ammPrivkey, url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ action: 'swap', sell: 'tbtc3', amount: 100 })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('no liquidity'));
+    });
+
+    it('POST /pay/.pool add-liquidity should fail with zero balance', async () => {
+      const url = `${ammUrl}/pay/.pool`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': ammNip98(ammPrivkey, url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ action: 'add-liquidity', tbtc3: 1000, tbtc4: 5000 })
+      });
+      assertStatus(res, 402);
+    });
+
+    it('POST /pay/.pool should reject unknown action', async () => {
+      const url = `${ammUrl}/pay/.pool`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': ammNip98(ammPrivkey, url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ action: 'invalid' })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('Unknown action'));
+    });
+
+    it('POST /pay/.pool swap should reject invalid sell unit', async () => {
+      const url = `${ammUrl}/pay/.pool`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': ammNip98(ammPrivkey, url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ action: 'swap', sell: 'invalid', amount: 100 })
+      });
+      assertStatus(res, 400);
+    });
+
+    it('POST /pay/.pool remove-liquidity should fail with no pool', async () => {
+      const url = `${ammUrl}/pay/.pool`;
+      const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Authorization': ammNip98(ammPrivkey, url, 'POST'),
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({ action: 'remove-liquidity', shares: 10 })
+      });
+      assertStatus(res, 400);
+      const body = await res.json();
+      assert.ok(body.error.includes('no liquidity'));
+    });
+  });
+
   describe('Pay disabled', () => {
     let noPayServer;
     let noPayUrl;

package/test/webledger.test.js

@@ -152,6 +152,68 @@ describe('Web Ledger', () => {
     });
   });
 
+  describe('multi-currency', () => {
+    it('should credit and debit with specific currency', () => {
+      const ledger = createLedger();
+      const bal = credit(ledger, 'did:nostr:user1', 1000, 'tbtc3');
+      assert.strictEqual(bal, 1000);
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1', 'tbtc3'), 1000);
+      // Default balance should be 0 (no satoshi credits)
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1'), 0);
+    });
+
+    it('should track multiple currencies independently', () => {
+      const ledger = createLedger();
+      credit(ledger, 'did:nostr:user1', 1000, 'tbtc3');
+      credit(ledger, 'did:nostr:user1', 5000, 'tbtc4');
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1', 'tbtc3'), 1000);
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1', 'tbtc4'), 5000);
+    });
+
+    it('should debit specific currency', () => {
+      const ledger = createLedger();
+      credit(ledger, 'did:nostr:user1', 1000, 'tbtc3');
+      credit(ledger, 'did:nostr:user1', 5000, 'tbtc4');
+      const result = debit(ledger, 'did:nostr:user1', 300, 'tbtc3');
+      assert.strictEqual(result.success, true);
+      assert.strictEqual(result.balance, 700);
+      // tbtc4 unchanged
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1', 'tbtc4'), 5000);
+    });
+
+    it('should fail debit when currency balance insufficient', () => {
+      const ledger = createLedger();
+      credit(ledger, 'did:nostr:user1', 100, 'tbtc3');
+      const result = debit(ledger, 'did:nostr:user1', 200, 'tbtc3');
+      assert.strictEqual(result.success, false);
+      assert.strictEqual(result.balance, 100);
+    });
+
+    it('should migrate simple string to array on currency credit', () => {
+      const ledger = createLedger();
+      // First set a simple balance
+      setBalance(ledger, 'did:nostr:user1', 500);
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1'), 500);
+      // Now add a currency-specific balance — should migrate to array
+      credit(ledger, 'did:nostr:user1', 1000, 'tbtc3');
+      assert.strictEqual(getBalance(ledger, 'did:nostr:user1', 'tbtc3'), 1000);
+      // Old satoshi balance should be preserved in array
+      const entry = ledger.entries.find(e => e.url === 'did:nostr:user1');
+      assert.ok(Array.isArray(entry.amount));
+      const satEntry = entry.amount.find(a => a.currency === 'satoshi');
+      assert.strictEqual(parseInt(satEntry.value), 500);
+    });
+
+    it('should use array format in entries', () => {
+      const ledger = createLedger();
+      credit(ledger, 'did:nostr:user1', 1000, 'tbtc3');
+      const entry = ledger.entries.find(e => e.url === 'did:nostr:user1');
+      assert.ok(Array.isArray(entry.amount));
+      assert.strictEqual(entry.amount[0].currency, 'tbtc3');
+      assert.strictEqual(entry.amount[0].value, '1000');
+    });
+  });
+
   describe('URI format support', () => {
     it('should work with did:nostr URIs', () => {
       const ledger = createLedger();