1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
// One balance (Adam, 2026-11-15: "combine the Ark and savings Bitcoin
// accounts into a single account … a combined history … the balance would be
// unified"). The Ark feature's side of it, without a browser:
// - the combined timeline tells a move between the two halves once: a board
// (its on-chain Sent + its Boarded) and an offboard to our own address
// (its Moved to Savings + the on-chain Received) are one row each, worth
// what the move cost; a board still confirming is one pending row; an
// offboard to someone else stays a payment
// - the separate Spending timeline is untouched
// - an on-chain address is paid from on-chain coins when there are any, and
// leaves Ark (offboard) only when there aren't
// Run: bun tools/unified-balance-test.js
import { buildFeatures } from '../src/features/index.js';
import { getArkConfig } from '../src/api.js';
let fails = 0;
const check = (name, ok, detail = '') => {
console.log(` ${ok ? '✓' : '✗'} ${name}${detail ? ' — ' + String(detail).slice(0, 240) : ''}`);
if (!ok) fails++;
};
globalThis.fetch = async () => { throw new Error('offline (test)'); };
globalThis.window = undefined;
globalThis.localStorage = {
_d: {}, getItem(k) { return this._d[k] ?? null; }, setItem(k, v) { this._d[k] = String(v); },
removeItem(k) { delete this._d[k]; }, key(i) { return Object.keys(this._d)[i] ?? null; },
get length() { return Object.keys(this._d).length; },
};
const cfg = getArkConfig();
localStorage.setItem('btc-wallet-arkinfo:' + cfg.ark, JSON.stringify({ info: { minBoardAmountSat: 1000, boardFees: {} }, tip: 1, at: Date.now() }));
const T = Date.now() - 3600_000;
const A = 'a'.repeat(64), B = 'b'.repeat(64), C = 'c'.repeat(64), D = 'd'.repeat(64), E = 'e'.repeat(64);
const arkState = {
_rev: 1,
vtxos: [{ id: 'v1', amountSat: 20000, state: 'spendable' }],
movements: [
{ id: 'm-board', type: 'board', amountSat: 9000, status: 'complete', txid: A, ts: T },
{ id: 'm-off', type: 'offboard', amountSat: 5000, feeSat: 300, status: 'complete', txid: B, to: 'bc1qown', ts: T + 1000 },
{ id: 'm-off-ext', type: 'offboard', amountSat: 7000, feeSat: 300, status: 'complete', txid: D, to: 'bc1qsomeoneelse', ts: T + 2000 },
{ id: 'm-recv', type: 'receive', amountSat: 1234, status: 'complete', vtxoId: 'v1', ts: T + 3000 },
],
actions: [
{ id: `board-${T + 4000}`, type: 'board', step: 'funded', amountSat: 3000, feeSat: 0, fundingTxid: C },
],
};
// the on-chain wallet's view: board fundings out, the own offboard in
const txs = [
{ txid: A, net: -9200, confirmed: true, blockTime: T / 1000 },
{ txid: B, net: 5000, confirmed: true, blockTime: (T + 1000) / 1000 },
{ txid: C, net: -3150, confirmed: false },
{ txid: E, net: 40000, confirmed: true, blockTime: (T + 5000) / 1000 },
];
const store = {};
const wallet = {
watchOnly: false, offline: false, spendable: 0, feeRates: { halfHourFee: 1 },
utxos: [], txs, history: txs, receive: [], change: [],
account: () => ({}),
isOnchainAddress: (a) => /^bc1q/.test(a),
loadFeatureState: (n, fb) => JSON.parse(store[n] || 'null') || fb,
saveFeatureState: (n, st) => { store[n] = JSON.stringify(st); },
_cacheKey: () => 'test', saveCache: () => {},
nostrPubkey: () => 'ab'.repeat(32),
registerCacheExtension: () => {}, registerRealtimeHook: () => {}, registerLoadHook: () => {},
registerScanHook: () => {}, registerCacheSavedHook: () => {}, registerCoinLock: () => {},
loadArkState: () => arkState, peekArkState: () => arkState, saveArkState: () => {},
_arkNs: () => 'ns', _arkKey: () => 'k', _arkHoldKey: () => 'h', _arkVtxoOwner: () => null, adoptArkState: () => null,
freshReceive: () => ({ address: 'bc1qtest' }), freshChange: () => ({ address: 'bc1qchange' }),
balance: () => ({ spendableSat: 0 }), emit: () => {}, on: () => {},
};
let unified = true;
const ui = { account: 'spending', send: { recipients: [{ address: '' }] } };
let features = [];
const ctx = {
h: (tag, attrs, ...kids) => ({ tag, attrs: attrs || {}, kids: kids.flat().filter((k) => k != null && k !== false) }),
ui, render: () => {}, wallet,
hook: (name, ...args) => { for (const f of features) if (f[name]) { const v = f[name](...args); if (v) return v; } return null; },
getAccount: () => ui.account, setAccount: (a) => { ui.account = a; }, unifiedBalance: () => unified,
goHome: () => {}, openMnemonic: async () => {},
fmtAmount: (n) => Number(n).toLocaleString('en-US'), unitLabel: () => 'sats', unitTag: () => 'sats', getUnit: () => 'sats',
parseAmount: (v) => parseInt(v, 10) || 0, amountField: (n) => String(n),
copyBtn: () => null, pasteBtn: () => null, toast: () => {}, blankSend: () => ({ recipients: [{ address: '' }] }),
openExternal: () => {},
};
features = buildFeatures(ctx);
const ark = features.find((f) => f.id === 'ark');
const text = (n) => typeof n === 'string' || typeof n === 'number' ? String(n) : n && n.kids ? n.kids.map(text).join(' ') : '';
console.log('[one timeline]');
{
const rows = ark.historyEntries(txs, 'all');
const replaced = rows.map((e) => e.replacesTxid).filter(Boolean).sort();
check('the board, the own offboard and the confirming board stand in for their on-chain rows', replaced.join() === [A, B, C].sort().join(), replaced.map((x) => x[0]).join());
check('the offboard to someone else is not a move', !replaced.includes(D));
const byTx = Object.fromEntries(rows.filter((e) => e.replacesTxid).map((e) => [e.replacesTxid, text(e.render())]));
check('the board reads Made instant, worth its cost (9,200 out, 9,000 in)', /Made instant/.test(byTx[A]) && /\b200\b/.test(byTx[A]) && /9,000/.test(byTx[A]), byTx[A]);
check('the own offboard reads Moved on-chain, worth its fee', /Moved on-chain/.test(byTx[B]) && /\b300\b/.test(byTx[B]), byTx[B]);
check('the confirming board is one pending row', /Making instant/.test(byTx[C]) && /Pending/.test(byTx[C]) && /\b150\b/.test(byTx[C]), byTx[C]);
const others = rows.filter((e) => !e.replacesTxid).map((e) => text(e.render())).join(' | ');
check('the other Ark rows are as they were', /Received/.test(others) && !/Boarded/.test(others), others);
check('the offboard to someone else reads Sent, not Moved to Savings', /Sent/.test(others) && !/Savings/.test(others), others);
}
console.log('[the Spending timeline, shown apart]');
{
const rows = ark.historyEntries([], 'spending');
check('no row stands in for an on-chain one', rows.every((e) => !e.replacesTxid), rows.length);
check('the board is still its own Boarded row', rows.some((e) => /Boarded/.test(text(e.render()))));
check('Savings gets no Ark rows', ark.historyEntries(txs, 'savings').length === 0);
}
console.log('[paying an on-chain address]');
{
ui.arkOffboardSend = null; wallet.spendable = 50000;
ark.matchSendText('bc1qrecipient');
check('with on-chain coins it is an ordinary on-chain send', !ui.arkOffboardSend);
ui.arkOffboardSend = null; wallet.spendable = 0;
ark.matchSendText('bc1qrecipient');
check('without them it leaves Ark', !!ui.arkOffboardSend && ui.arkOffboardSend.address === 'bc1qrecipient');
ui.arkOffboardSend = null; wallet.spendable = 50000; unified = false;
ark.matchSendText('bc1qrecipient');
check('shown apart, Spending still pays it from Ark (as before)', !!ui.arkOffboardSend);
}
console.log(fails ? `FAIL (${fails})` : 'PASS');
process.exit(fails ? 1 : 0);
|