);
}
/* ===================== NEW TRANSFER MODAL ===================== */
function TransferModal({ rows, setRows, clients, setClients, settings, me, log, corridors, beneficiaries, setBeneficiaries, transfers, setTransfers, onClose, onDone, serverBacked, onServerPosted }) {
/* One idempotency key per ticket — see the long note on `attemptKey`
in cdos-txmodal.jsx. The key used to be the browser's guessed
TR--NNN, which restarts at 001 on every fresh sign-in, so a
till's second-ever transfer replayed its first and moved no cash
while the screen said posted. A refused deal leaves no idempotency
row, so re-submitting a corrected ticket under the same key is
right; a new ticket gets a new one. */
const attempt = useRef(null);
const attemptKey = () => {
if (!attempt.current)
attempt.current = (window.crypto && window.crypto.randomUUID)
? window.crypto.randomUUID()
: 'k' + Date.now().toString(36) + Math.random().toString(36).slice(2);
return attempt.current;
};
const [direction, setDirection] = useState('send');
const [senderName, setSenderName] = useState('');
const [benId, setBenId] = useState('');
const [addBen, setAddBen] = useState(false);
const [corridorId, setCorridorId] = useState('PH');
const [partner, setPartner] = useState('');
const [method, setMethod] = useState('cash');
const [payAmt, setPayAmt] = useState('');
const [fee, setFee] = useState(settings && settings.defaultFee ? String(settings.defaultFee) : '9.99');
const requirePurpose = !(settings && settings.transferRequirePurpose === false); // Settings › Transfers
const [purpose, setPurpose] = useState(requirePurpose ? '' : 'Family support');
const [sourceOfFunds, setSourceOfFunds] = useState('Salary');
const senderWrap = useRef(null);
const [senderOpen, setSenderOpen] = useState(false);
/* The post is a round trip now, so the button has to be able to say
so and the modal has to be able to refuse. There is no offline
mode — docs/CASH_OWNERSHIP_INVARIANTS.md — so a transfer the
ledger did not accept is a transfer that did not happen, and the
browser record is not written. */
const [busy, setBusy] = useState(false);
const [serverError, setServerError] = useState('');
const names = useMemo(() => { const s = new Set(Object.keys(clients)); rows.forEach(r => r.customer && s.add(r.customer)); return Array.from(s).sort(); }, [clients, rows]);
const myBens = beneficiaries.filter(b => direction === 'send' && (!senderName || b.sender === senderName));
const ben = beneficiaries.find(b => b.id === benId);
// when a saved beneficiary is picked, it drives corridor/partner/method
useEffect(() => { if (ben) { setCorridorId(ben.corridor); setMethod(ben.method); setPartner(ben.partner); } }, [benId]);
const cor = corridors.find(c => c.id === corridorId) || corridors[0];
const recvCcy = cor.ccy;
const partners = cor.partners.filter(p => p.methods.includes(method));
useEffect(() => { if (!partners.find(p => p.name === partner)) setPartner(partners[0] ? partners[0].name : ''); }, [corridorId, method]);
const amtN = parseFloat(payAmt) || 0;
// SEND: customer pays CAD, beneficiary gets foreign. RECEIVE: foreign in, customer gets CAD.
const pricing = useMemo(() => direction === 'send'
? priceDeal({ inCcy: 'CAD', outCcy: recvCcy, inAmt: amtN, settings })
: priceDeal({ inCcy: recvCcy, outCcy: 'CAD', inAmt: amtN, settings }), [direction, recvCcy, amtN, settings]);
const recvAmt = pricing.outAmt;
const payCad = direction === 'send' ? amtN + (parseFloat(fee) || 0) : 0;
const cadEquiv = direction === 'send' ? amtN : cadOf(amtN, recvCcy);
/* The desk's own reporting line, from the jurisdiction pack. Null-safe:
with no threshold to compare against the honest answer is "cannot
say", and treating that as "not reportable" clears a deal nobody
checked. */
const limit = reportingLimit(settings);
const reportable = limit.amount != null && cadEquiv >= limit.amount;
const kyc = (() => { const c = clients[senderName]; return !c || !c.idType || !c.idNum ? 'missing ID' : (c.idExpiry && c.idExpiry < TODAY ? 'ID expired' : 'ok'); })();
const idRequired = cadEquiv >= (settings.idRequiredOver || 3000);
const needBen = direction === 'send';
const canSave = amtN > 0 && partner && (!needBen || benId) && senderName && !(idRequired && kyc !== 'ok') && (!requirePurpose || purpose);
const pickSender = (n) => { setSenderName(n); setSenderOpen(false); setBenId(''); };
useEffect(() => { const h = (e) => { if (senderWrap.current && !senderWrap.current.contains(e.target)) setSenderOpen(false); }; document.addEventListener('mousedown', h); return () => document.removeEventListener('mousedown', h); }, []);
useEffect(() => { const h = (e) => { if (e.key === 'Escape') onClose(); }; document.addEventListener('keydown', h); return () => document.removeEventListener('keydown', h); }, [onClose]);
/* ---- creating a transfer ----
This used to be a synchronous function that pushed two objects
into two arrays. The cash it represented never reached the server,
so a shop that did twenty of these closed the day with a drawer
that disagreed with its own ledger by whatever it had taken in,
and the compliance aggregate could not see any of it.
Now the LEDGER goes first and the browser record follows it. On a
send the desk takes cash and books a payout it owes the corridor
partner; on a receive it counts cash out against what the partner
owes it. Neither claims a rate margin, because the partner's price
is not a thing this product knows — see docs/OBLIGATION_LINES.md,
which also names the one field it would need to. The fee is the
only thing booked as earned.
If the server refuses, nothing at all is recorded here. A movement
that succeeded in the browser and never reached the server is a
loss, and there is no offline mode to fall back on. */
const create = async () => {
if (!canSave || busy) return;
const seqT = transfers.filter(t => t.date === TODAY).length + 1;
const ref = 'TR-' + String(TODAY).slice(2).replace(/-/g, '') + '-' + String(seqT).padStart(3, '0');
const pin = (Math.floor(10 + Math.random() * 89) + ' ' + Math.floor(100 + Math.random() * 899) + ' ' + Math.floor(100 + Math.random() * 899));
const seqL = rows.filter(r => r.date === TODAY && r.status !== 'void').length + 1;
const lref = mkRef(TODAY, seqL);
const lin = direction === 'send' ? 'CAD' : recvCcy, lout = direction === 'send' ? recvCcy : 'CAD';
const feeN = parseFloat(fee) || 0;
const B = serverBacked && window.CDOS.Backend ? window.CDOS.Backend : null;
let posted = null;
if (B) {
setBusy(true);
setServerError('');
try {
const synced = await B.syncCustomer(senderName, clients[senderName]);
setClients && setClients(list => ({ ...list, [senderName]: { ...(list[senderName] || {}), ledgerCustomerId: synced.customerId, ledgerExternalRef: synced.externalRef } }));
const capture = {
purpose: (purpose || '').trim(),
sourceOfFunds: (sourceOfFunds || '').trim(),
/* The server decides whether these were NEEDED, against the
desk's own reporting line. Sending them unconditionally
and letting one authority judge them is the whole point —
a second threshold in this file is a second rule to drift. */
};
posted = direction === 'send'
? await B.postRemittanceSend({
idempotencyKey: 'web:transfer:' + attemptKey(),
customerId: synced.customerId,
reference: ref,
principalAmount: B.asMoney(amtN),
feeAmount: B.asMoney(feeN),
payoutCurrency: recvCcy,
payoutAmount: B.asMoney(recvAmt),
corridor: corridorId,
partner: partner,
beneficiaryName: (ben ? ben.name : senderName),
...capture,
})
: await B.postRemittanceReceive({
idempotencyKey: 'web:transfer:' + attemptKey(),
customerId: synced.customerId,
reference: ref,
sentCurrency: recvCcy,
sentAmount: B.asMoney(amtN),
payoutAmount: B.asMoney(recvAmt),
feeAmount: B.asMoney(feeN),
corridor: corridorId,
partner: partner,
...capture,
});
} catch (error) {
setServerError(error.message || 'The transfer was not posted.');
setBusy(false);
return;
}
setBusy(false);
}
/* The transfer's reference, and whose it is.
`ref` above is a guess: it counts THIS browser's transfer list,
which is empty on a till that has just been signed into and on
every other machine in the shop. Two tills doing their first
remittance of the day both guessed TR--001, and the second
one was refused by the ledger's uniqueness rule as an
"Unexpected server error" — a teller holding the customer's cash
and no way to know whose fault it was.
So the book names it, exactly as it already names transactions,
and what is used from here down is the name that came back. The
guess survives only as the reference the desk quoted at the
counter, which the ledger keeps on the obligation's opening
event. */
const oref = posted ? posted.obligationRef : ref;
const tx = newTx({
ref: posted ? posted.transactionRef : lref,
type: direction === 'send' ? 'Remittance — Send' : 'Remittance — Receive',
customer: senderName, inCcy: lin, inAmt: amtN, rate: pricing.rate, outCcy: lout, outAmt: recvAmt,
fee: feeN, midRate: pricing.midRate,
/* Null where the ledger holds the deal, because the ledger books
no spread on a remittance and a figure here that the book does
not have is the second opinion this product keeps deleting. */
spreadCad: posted ? null : pricing.marginCad, side: pricing.side,
teller: me.name, notes: `${oref} · ${direction === 'send' ? 'to ' + (ben ? ben.name : '') : 'from ' + senderName} (${cor.country}) · ${partner}`,
transferRef: oref, createdBy: me.name, createdAt: stamp(),
serverTransactionId: posted ? posted.transactionId : null,
serverObligationId: posted ? posted.obligationId : null,
});
setRows(r => [tx, ...r]);
const transfer = {
id: 't' + Date.now(), ref: oref, pin, direction, senderName, beneficiaryId: benId || null, corridor: corridorId, ccy: recvCcy,
method, partner, payAmt: amtN, recvAmt, rate: pricing.rate, midRate: pricing.midRate,
spreadCad: posted ? null : pricing.marginCad,
fee: feeN, purpose, sourceOfFunds, date: TODAY, status: 'created', txId: tx.id,
txRef: posted ? posted.transactionRef : lref,
/* The ledger's own names for this deal and the promise it left
behind, so the browser record and the book can be joined. The
browser holds no cash figure of its own. */
serverTransactionId: posted ? posted.transactionId : null,
serverObligationId: posted ? posted.obligationId : null,
timeline: [{ status: 'created', ts: stamp(), by: me.name }], createdBy: me.name,
};
setTransfers(t => [transfer, ...t]);
log && log('Transfer created', `${oref} · ${num(amtN)} ${direction === 'send' ? 'CAD → ' + num(recvAmt) + ' ' + recvCcy : recvCcy + ' → ' + num(recvAmt) + ' CAD'} · ${cor.country}${posted ? ' · server ledger' : ''}${reportable ? ' · EFT REPORTABLE' : ''}`);
if (posted && onServerPosted) {
try { await onServerPosted(); }
catch (refreshError) { log && log('Ledger refresh failed', refreshError.message || 'The drawer will refresh on the next ledger open'); }
}
onDone && onDone(transfer.id);
};
const saveBen = (b) => { setBeneficiaries(list => { const ex = list.find(x => x.id === b.id); return ex ? list.map(x => x.id === b.id ? b : x) : [b, ...list]; }); setBenId(b.id); setAddBen(false); log && log('Beneficiary saved', `${b.name} · ${b.partner}`); };
return (
{/* onBlur closes it, and it has to, because the
document-level mousedown listener below cannot.
The modal card stops mousedown propagating (so a
click inside the form does not reach the scrim's
close handler), and React dispatches from the root
container — so that stopPropagation also stops the
listener on `document` ever seeing a click made
INSIDE the form. The list was therefore impossible to
put away without picking a name from it, and it is
positioned over the beneficiary picker: a sender the
desk has never dealt with before left the teller
unable to reach their own beneficiary list.
Safe alongside the suggestions because each of them
preventDefaults its mousedown, which is what stops
the blur firing before the pick registers. */}
setSenderOpen(true)} onBlur={() => setSenderOpen(false)} onChange={e => { setSenderName(e.target.value); setSenderOpen(true); setBenId(''); }} placeholder="Type a name…" className="w-full outline-none text-sm bg-transparent" />
{senderName && }
{/* What the desk can actually claim to have earned. On the
ledger that is the fee and nothing else: the rate margin
is not knowable until the payout is bought from the
corridor partner, and this product does not carry the
partner's price. Saying "spread captured" over a figure
measured against the market mid told the teller the desk
had made money it had not yet made — the same estimate
docs/COST_BASIS.md records the removal of. It is
recognized on the Settlement tab, against a real price. */}
{serverBacked
? <>Booked now: {fmt(parseFloat(fee) || 0, 'CAD')} fee · rate margin at settlement
: <>Spread captured {fmt(pricing.marginCad, 'CAD')}{(parseFloat(fee) || 0) > 0 && · +{fmt(fee, 'CAD')} fee}}
{direction === 'send' && Collect {fmt(payCad, 'CAD')}}