@stamhoofd/backend 2.143.1 → 2.144.0

package/src/helpers/MollieSettlementSync.test.ts

@@ -191,25 +191,16 @@ describe('Helper.MollieSettlementSync', () => {
         test('legacy JSON and new rows agree, and the settlement reconciles to zero', async () => {
             const { organization, token, payment, refundPayment, mockPayment, mockRefund } = await init();
 
-            // 50.00 - 20.00 in entries, minus 0.30 costs + 0.06 VAT
+            // 50.00 - 20.00 in entries, minus a 0.30 payment fee and a 0.06 refund fee
             const settlement = mollieMocker.createSettlement({
                 payments: [mockPayment],
                 refunds: [mockRefund],
                 value: '29.64',
-                invoiceId: 'inv_123',
-                periods: {
-                    2026: {
-                        '01': {
-                            costs: [{
-                                description: 'Bancontact betalingen',
-                                method: 'bancontact',
-                                amountNet: { currency: 'EUR', value: '0.30' },
-                                amountVat: { currency: 'EUR', value: '0.06' },
-                            }],
-                        },
-                    },
-                },
             });
+            mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '0.30', createdAt: new Date(2026, 0, 5) });
+
+            // A transaction without the deductionDetails breakdown: its whole deduction is the fee
+            mollieMocker.createBalanceTransaction({ type: 'refund', entryId: mockRefund.id, deductions: '0.06', createdAt: new Date(2026, 0, 6) });
 
             await runCron(token);
 
@@ -230,61 +221,93 @@ describe('Helper.MollieSettlementSync', () => {
             ].sort());
 
             const charges = await SettlementCharge.select().where('settlementId', row.id).fetch();
-            expect(charges.map(c => ({ type: c.type, amount: c.amount, providerInvoiceId: c.providerInvoiceId, occurredAt: c.occurredAt })).sort((a, b) => a.amount - b.amount)).toEqual([
-                { type: SettlementChargeType.ProviderTransactionFee, amount: -30_00, providerInvoiceId: 'inv_123', occurredAt: new Date(2026, 0, 1) },
-                { type: SettlementChargeType.Tax, amount: -6_00, providerInvoiceId: 'inv_123', occurredAt: new Date(2026, 0, 1) },
+            expect(charges.map(c => ({ type: c.type, amount: c.amount, paymentId: c.paymentId, occurredAt: c.occurredAt })).sort((a, b) => a.amount - b.amount)).toEqual([
+                { type: SettlementChargeType.ProviderTransactionFee, amount: -30_00, paymentId: payment.id, occurredAt: new Date(2026, 0, 5) },
+                { type: SettlementChargeType.ProviderTransactionFee, amount: -6_00, paymentId: refundPayment.id, occurredAt: new Date(2026, 0, 6) },
             ]);
 
+            // Each payment holds the fee that was deducted for it
+            expect((await Payment.getByID(payment.id))!.transferFee).toBe(30_00);
+            expect((await Payment.getByID(refundPayment.id))!.transferFee).toBe(6_00);
+
             // The legacy blob agrees with the new settlement row
             const updatedPayment = await Payment.getByID(payment.id);
             expect(updatedPayment!.settlement!.id).toBe(row.externalId);
             expect(updatedPayment!.settlement!.amount).toBe(row.amount);
         });
 
-        test('the invoiceId is filled in on a later re-walk', async () => {
-            const { token, mockPayment } = await init();
+        test('the fee of a chargeback is stored on its settlement and payment', async () => {
+            const { organization, token, payment, mockPayment } = await init();
+            const { chargebackPayment, mockChargeback } = await addChargeback(organization.id, payment, mockPayment);
+
+            // 50.00 - 50.00 in entries, minus a 0.25 chargeback fee
             const settlement = mollieMocker.createSettlement({
                 payments: [mockPayment],
-                value: '49.70',
-                periods: {
-                    2026: {
-                        '01': {
-                            costs: [{
-                                description: 'Bancontact betalingen',
-                                method: 'bancontact',
-                                amountNet: { currency: 'EUR', value: '0.30' },
-                                amountVat: { currency: 'EUR', value: '0.00' },
-                            }],
-                        },
-                    },
-                },
+                chargebacks: [mockChargeback],
+                value: '-0.25',
             });
+            mollieMocker.createBalanceTransaction({ type: 'chargeback', entryId: mockChargeback.id, fee: '0.25' });
 
             await runCron(token);
+
             const row = await getSettlementRow(settlement.id);
-            const costs = await SettlementCharge.select().where('settlementId', row.id).fetch();
-            expect(costs).toHaveLength(1);
-            expect(costs[0].providerInvoiceId).toBeNull();
+            expect(row.unexplainedAmount).toBe(0);
+
+            const charges = await SettlementCharge.select().where('paymentId', chargebackPayment.id).fetch();
+            expect(charges.map(c => ({ type: c.type, amount: c.amount, settlementId: c.settlementId }))).toEqual([
+                { type: SettlementChargeType.ProviderTransactionFee, amount: -25_00, settlementId: row.id },
+            ]);
+            expect((await Payment.getByID(chargebackPayment.id))!.transferFee).toBe(25_00);
+        });
+
+        test('only the fee part of a deduction becomes a charge', async () => {
+            const { token, payment, mockPayment } = await init();
+
+            // Mollie withheld 5.30: a 0.30 fee plus a 5.00 reserve, which stays unexplained
+            const settlement = mollieMocker.createSettlement({ payments: [mockPayment], value: '44.70' });
+            mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '0.30', deductions: '5.30' });
+
+            await runCron(token);
+
+            const charges = await SettlementCharge.select().where('paymentId', payment.id).fetch();
+            expect(charges.map(c => c.amount)).toEqual([-30_00]);
+            expect((await Payment.getByID(payment.id))!.transferFee).toBe(30_00);
+            expect((await getSettlementRow(settlement.id)).unexplainedAmount).toBe(-5_0000);
+        });
+
+        test('the fee of a settlement that is not stored yet is stored on a later walk', async () => {
+            const { token, payment, mockPayment } = await init();
+            mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '0.30' });
+
+            // The transaction exists before its settlement is paid out: there is nothing to
+            // attach the fee to yet
+            await runCron(token);
+            expect(await SettlementCharge.select().where('paymentId', payment.id).count()).toBe(0);
 
-            // Mollie created the invoice since the last walk
-            settlement.invoiceId = 'inv_later';
+            const settlement = mollieMocker.createSettlement({ payments: [mockPayment], value: '49.70' });
             await runCron(token);
 
-            const updated = await SettlementCharge.getByID(costs[0].id);
-            expect(updated!.providerInvoiceId).toBe('inv_later');
+            const row = await getSettlementRow(settlement.id);
+            expect(row.unexplainedAmount).toBe(0);
+            expect(await SettlementCharge.select().where('paymentId', payment.id).count()).toBe(1);
         });
 
         test('re-running stores identical rows', async () => {
             const { token, mockPayment, mockRefund } = await init();
-            const settlement = mollieMocker.createSettlement({ payments: [mockPayment], refunds: [mockRefund], value: '30.00' });
+            const settlement = mollieMocker.createSettlement({ payments: [mockPayment], refunds: [mockRefund], value: '29.70' });
+            mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '0.30' });
 
             await runCron(token);
             const row = await getSettlementRow(settlement.id);
             const before = (await PaymentSettlement.select().where('settlementId', row.id).fetch()).map(l => l.id).sort();
+            const chargesBefore = (await SettlementCharge.select().where('settlementId', row.id).fetch()).map(c => c.id).sort();
 
             await runCron(token);
             const after = (await PaymentSettlement.select().where('settlementId', row.id).fetch()).map(l => l.id).sort();
+            const chargesAfter = (await SettlementCharge.select().where('settlementId', row.id).fetch()).map(c => c.id).sort();
             expect(after).toEqual(before);
+            expect(chargesAfter).toEqual(chargesBefore);
+            expect(chargesBefore).toHaveLength(1);
             expect(await Settlement.select().where('externalId', settlement.id).count()).toBe(1);
         });
     });
@@ -333,6 +356,34 @@ describe('Helper.MollieSettlementSync', () => {
         expect(await Settlement.select().where('externalId', beforeWindow.id).count()).toBe(0);
     });
 
+    test('The fee walk follows pagination and stops before the window', async () => {
+        const { organization, token, payment, mockPayment, mockRefund } = await init();
+        const { mockChargeback } = await addChargeback(organization.id, payment, mockPayment);
+        mollieMocker.balanceTransactionsPageSize = 2;
+
+        const settlement = mollieMocker.createSettlement({
+            payments: [mockPayment],
+            refunds: [mockRefund],
+            chargebacks: [mockChargeback],
+            value: '100.00',
+        });
+
+        // Three fee transactions across two pages, newest first
+        mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '0.30', createdAt: new Date(2026, 2, 3) });
+        mollieMocker.createBalanceTransaction({ type: 'refund', entryId: mockRefund.id, fee: '0.06', createdAt: new Date(2026, 2, 2) });
+        mollieMocker.createBalanceTransaction({ type: 'chargeback', entryId: mockChargeback.id, fee: '0.25', createdAt: new Date(2026, 2, 1) });
+
+        // Before the window (minus the lookback): the walk may not reach this one
+        const beforeWindow = mollieMocker.createBalanceTransaction({ type: 'payment', entryId: mockPayment.id, fee: '9.99', createdAt: new Date(2019, 0, 1) });
+
+        await runCron(token);
+
+        const row = await Settlement.select().where('externalId', settlement.id).first(true);
+        const charges = await SettlementCharge.select().where('settlementId', row.id).fetch();
+        expect(charges.map(c => c.amount).sort((a, b) => a - b)).toEqual([-30_00, -25_00, -6_00]);
+        expect(charges.map(c => c.externalId)).not.toContain(beforeWindow.id);
+    });
+
     test('The summary counts synced settlements', async () => {
         const { token, mockPayment } = await init();
         mollieMocker.createSettlement({ payments: [mockPayment], value: '50.00' });
@@ -394,11 +445,13 @@ describe('Helper.MollieSettlementSync', () => {
             refunds: [unlinkedRefund, mockRefund],
             value: '100.00',
         });
+        const unlinkedFee = mollieMocker.createBalanceTransaction({ type: 'refund', entryId: unlinkedRefund.id, fee: '0.06' });
 
         await runCron(token);
 
-        // The known refund still gets its settlement, the unlinked one is silently ignored
+        // The known refund still gets its settlement, the unlinked one and its fee are silently ignored
         const updatedRefund = await Payment.getByID(refundPayment.id);
         expect(updatedRefund!.settlement).toMatchObject({ id: settlement.id });
+        expect(await SettlementCharge.select().where('externalId', unlinkedFee.id).count()).toBe(0);
     });
 });

package/src/helpers/MollieSettlementSync.ts

@@ -1,29 +1,16 @@
 import type { MollieToken } from '@stamhoofd/models';
 import { MolliePayment, Payment } from '@stamhoofd/models';
+import { PaymentSettlement } from '@stamhoofd/models/models/PaymentSettlement.js';
 import type { Settlement } from '@stamhoofd/models/models/Settlement.js';
 import type { AbortSignal } from '@stamhoofd/queues';
 import { PaymentProvider } from '@stamhoofd/structures';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementStatus.js';
 import axios from 'axios';
-import { createHash } from 'crypto';
 
-import { ReportedRows, SettlementService } from '../services/SettlementService.js';
+import { SettlementService } from '../services/SettlementService.js';
 import type { SettlementSyncSummary } from './ProviderSettlementSyncRunner.js';
 
-type MollieSettlementCost = {
-    description: string;
-    method: string | null;
-    amountNet: {
-        currency: string;
-        value: string;
-    };
-    amountVat: {
-        currency: string;
-        value: string;
-    } | null;
-};
-
 type MollieSettlement = {
     id: string;
     reference: string;
@@ -34,20 +21,47 @@ type MollieSettlement = {
         currency: string;
         value: string;
     };
+};
+
+type MollieAmount = {
+    currency: string;
+    value: string;
+};
+
+type MollieBalanceTransaction = {
+    id: string;
+    type: string;
+    createdAt: string;
+
     /**
-     * "The ID of the oldest invoice created for all the periods": null until Mollie created it,
-     * filled in by the regular re-walk of recent settlements.
+     * Everything Mollie withheld from the movement (negative): fees, but also reserves, partner
+     * commissions and loan repayments. `deductionDetails` separates those.
      */
-    invoiceId?: string | null;
-    periods?: Record<string, Record<string, { costs?: MollieSettlementCost[]; invoiceId?: string | null }>>;
+    deductions?: MollieAmount | null;
+    deductionDetails?: {
+        fees?: MollieAmount | null;
+    } | null;
+    context?: {
+        paymentId?: string;
+        refundId?: string;
+        chargebackId?: string;
+    } | null;
 };
 
+/**
+ * A transaction occurs before the settlement that pays it out: up to a month (Mollie settles
+ * daily, weekly or monthly) plus a few days of payout delay. The fee walk looks this much further
+ * back than the settlement window.
+ */
+const TRANSACTION_FEE_LOOKBACK_MS = 45 * 24 * 60 * 60 * 1000;
+
 /**
  * Everything one settlement walk needs to share between the resource pages.
  */
 type SettlementSyncState = {
     settlementRow: Settlement;
-    reported: ReportedRows;
+
+    transactionCount: 0;
 
     /**
      * Stops the walk at the next entry (a restart).
@@ -80,10 +94,10 @@ type MollieSettlementEntryJSON = {
 };
 
 /**
- * Walks the settlements of one Mollie account and stores every entry in them: payments, refunds
- * and chargebacks become payment_settlements rows, Mollie's own costs become settlement_charges
- * rows, and the legacy blob is written in the same pass. Every settlement row written belongs to
- * the organization that owns the token's account.
+ * Walks the settlements of one Mollie account: payments, refunds and chargebacks become
+ * payment_settlements rows, and the legacy blob is written in the same pass. A second walk over
+ * the balance transactions stores the fee Mollie deducted per transaction as a settlement_charges
+ * row. Every row written belongs to the organization that owns the token's account.
  */
 export class MollieSettlementSync {
     private token: MollieToken;
@@ -92,12 +106,23 @@ export class MollieSettlementSync {
         this.token = token;
     }
 
+    async syncSettlements({ start, end = new Date(), summary, abort }: {
+        start: Date;
+        end?: Date;
+        summary?: SettlementSyncSummary;
+        abort?: AbortSignal;
+    }): Promise<void> {
+        // Fees attach to the settlement lines the first walk stores
+        await this.#walkSettlements({ start, end, summary, abort });
+        await this.#syncTransactionFees({ start, end, abort });
+    }
+
     /**
      * Walk the settlements newest first, until they settle before `start`.
      */
-    async syncSettlements({ start, end = new Date(), summary, abort }: {
+    async #walkSettlements({ start, end, summary, abort }: {
         start: Date;
-        end?: Date;
+        end: Date;
         summary?: SettlementSyncSummary;
         abort?: AbortSignal;
     }): Promise<void> {
@@ -191,7 +216,7 @@ export class MollieSettlementSync {
 
         const state: SettlementSyncState = {
             settlementRow,
-            reported: new ReportedRows(),
+            transactionCount: 0,
             abort,
         };
 
@@ -207,12 +232,8 @@ export class MollieSettlementSync {
             // chargeback payment (created by the mollie-chargebacks cron).
             await this.#syncResource(settlement, 'chargebacks', state);
 
-            // Mollie's own costs, so the settlement reconciles to 0 like a Stripe one
-            await this.#storeMollieCosts(settlement, state);
-
-            await SettlementService.sweepSettlement(settlementRow, state.reported);
             await SettlementService.finishSync(settlementRow, {
-                transactionCount: state.reported.paymentLineExternalIds.size + state.reported.chargeExternalIds.size,
+                transactionCount: state.transactionCount,
             });
         } catch (e) {
             // A walk that was interrupted stored only part of the settlement: it has to be walked
@@ -227,48 +248,127 @@ export class MollieSettlementSync {
     }
 
     /**
-     * Mollie invoices its costs per period: every cost line becomes a ProviderTransactionFee row plus
-     * a Tax row for its VAT, carrying the settlement's invoiceId so they can be matched against the
-     * invoice document.
+     * Stores the fee of every settled payment, refund and chargeback, then recounts the
+     * settlements that gained charges: their finishSync ran before the fees existed.
      */
-    async #storeMollieCosts(settlement: MollieSettlement, state: SettlementSyncState) {
-        for (const [year, months] of Object.entries(settlement.periods ?? {})) {
-            for (const [month, period] of Object.entries(months)) {
-                // Mollie states the period explicitly: that month is the cost's date, so the monthly
-                // grouping stays derivable from occurredAt alone
-                const occurredAt = new Date(parseInt(year), parseInt(month) - 1, 1);
-
-                // A settlement can straddle a month boundary: each period can be billed on its own
-                // invoice, the settlement-level id is only "the oldest invoice of all the periods"
-                const invoiceId = period.invoiceId ?? settlement.invoiceId;
-
-                for (const cost of period.costs ?? []) {
-                    // Mollie aggregates cost lines per description + method, so that pair identifies
-                    // the line within the period (hashed to keep the externalId short)
-                    const hash = createHash('sha256').update(cost.description + ':' + (cost.method ?? '')).digest('hex').slice(0, 16);
-                    const externalId = settlement.id + ':' + year + '-' + month + ':cost:' + hash;
-                    const description = cost.description + (cost.method ? ' (' + cost.method + ')' : '');
-
-                    const rows = [
-                        { type: SettlementChargeType.ProviderTransactionFee, externalId, amount: -mollieAmountToUnits(cost.amountNet.value) },
-                        ...(cost.amountVat && mollieAmountToUnits(cost.amountVat.value) !== 0
-                            ? [{ type: SettlementChargeType.Tax, externalId: externalId + ':tax', amount: -mollieAmountToUnits(cost.amountVat.value) }]
-                            : []),
-                    ];
-
-                    for (const row of rows) {
-                        const charge = await SettlementService.upsertCharge({
-                            ...row,
-                            settlementId: state.settlementRow.id,
-                            organizationId: state.settlementRow.organizationId,
-                            ...(invoiceId ? { providerInvoiceId: invoiceId } : {}),
-                            description,
-                            occurredAt,
-                        });
-                        state.reported.charge(charge);
-                    }
+    async #syncTransactionFees({ start, end, abort }: { start: Date; end: Date; abort?: AbortSignal }): Promise<void> {
+        const touchedSettlementIds = new Set<string>();
+
+        try {
+            await this.#walkTransactionFees({ start, end, abort }, touchedSettlementIds);
+        } catch (e) {
+            // Recount what was stored before the walk broke, without hiding what broke it
+            await SettlementService.refreshTotalsForIds([...touchedSettlementIds]).catch(console.error);
+            throw e;
+        }
+
+        await SettlementService.refreshTotalsForIds([...touchedSettlementIds]);
+    }
+
+    /**
+     * Walk the balance transactions newest first, until they occur before the window minus the
+     * lookback.
+     */
+    async #walkTransactionFees({ start, end, abort }: { start: Date; end: Date; abort?: AbortSignal }, touchedSettlementIds: Set<string>): Promise<void> {
+        const oldest = new Date(start.getTime() - TRANSACTION_FEE_LOOKBACK_MS);
+        let url: string | null = 'https://api.mollie.com/v2/balances/primary/transactions?limit=250';
+
+        while (url) {
+            abort?.throwIfAborted();
+
+            const request = await this.#get(url);
+
+            if (request.status !== 200) {
+                console.error('Failed to fetch balance transactions for organization', this.token.organizationId);
+                console.error(request.data);
+                return;
+            }
+
+            const transactions = request.data._embedded?.balance_transactions as MollieBalanceTransaction[] | undefined;
+            if (!transactions) {
+                console.error('Unreadable balance transactions');
+                return;
+            }
+
+            for (const transaction of transactions) {
+                abort?.throwIfAborted();
+
+                const createdAt = new Date(transaction.createdAt);
+
+                if (isNaN(createdAt.getTime())) {
+                    console.error('Received an invalid balance transaction createdAt from Mollie', transaction, 'for organization', this.token.organizationId);
+                    continue;
                 }
+
+                if (createdAt.getTime() > end.getTime()) {
+                    continue;
+                }
+
+                if (createdAt.getTime() < oldest.getTime()) {
+                    // The list is newest-first: everything from here on occurred before the window
+                    return;
+                }
+
+                await this.#storeTransactionFee(transaction, createdAt, touchedSettlementIds);
             }
+
+            const next = request.data._links?.next?.href as string | undefined;
+            url = (transactions.length > 0 && next) ? next : null;
+        }
+    }
+
+    /**
+     * The settled entry a balance transaction belongs to. Every other transaction type (transfers,
+     * reserves, corrections, ...) is ignored for now.
+     */
+    #getTransactionEntryId(transaction: MollieBalanceTransaction): string | null {
+        switch (transaction.type) {
+            case 'payment': return transaction.context?.paymentId ?? null;
+            case 'refund': return transaction.context?.refundId ?? null;
+            case 'chargeback': return transaction.context?.chargebackId ?? null;
+            default: return null;
+        }
+    }
+
+    /**
+     * Store the fee Mollie deducted for one settled entry: a charge on the settlement the entry
+     * was paid out in, linked to the local payment.
+     */
+    async #storeTransactionFee(transaction: MollieBalanceTransaction, createdAt: Date, touchedSettlementIds: Set<string>) {
+        const entryId = this.#getTransactionEntryId(transaction);
+        if (!entryId) {
+            return;
+        }
+
+        // Reserves, commissions and repayments are not costs of this entry; a transaction without
+        // the breakdown carries its whole deduction as fees
+        const amount = mollieAmountToUnits(transaction.deductionDetails?.fees?.value ?? transaction.deductions?.value ?? '0');
+        if (amount === 0) {
+            return;
+        }
+
+        // No line: the entry belongs to a different system on the same account, or its settlement
+        // isn't stored yet and a later walk revisits this transaction
+        const line = await PaymentSettlement.select().where('externalId', entryId).first(false);
+        if (!line) {
+            return;
+        }
+
+        await SettlementService.upsertCharge({
+            type: SettlementChargeType.ProviderTransactionFee,
+            externalId: transaction.id,
+            amount,
+            settlementId: line.settlementId,
+            paymentId: line.paymentId,
+            organizationId: line.organizationId,
+            occurredAt: createdAt,
+        });
+        touchedSettlementIds.add(line.settlementId);
+
+        const payment = await Payment.getByID(line.paymentId);
+        if (payment) {
+            payment.transferFee = -amount;
+            await payment.save();
         }
     }
 
@@ -309,6 +409,7 @@ export class MollieSettlementSync {
      */
     async #applySettlementToPayment(settlement: MollieSettlement, mollieId: string, state: SettlementSyncState) {
         // Search payment
+        state.transactionCount += 1;
         const mps = await MolliePayment.where({ mollieId });
         if (mps.length === 1) {
             const mp = mps[0];
@@ -322,21 +423,16 @@ export class MollieSettlementSync {
                     return;
                 }
 
-                state.reported.paymentLine(await SettlementService.upsertPaymentLine(state.settlementRow, {
+                await SettlementService.upsertPaymentLine(state.settlementRow, {
                     paymentId: payment.id,
                     amount: payment.price,
                     externalId: mollieId,
                     occurredAt: new Date(settlement.settledAt),
-                }));
+                });
 
                 // The blob is written from the stored rows, so it stays deterministic across
                 // re-syncs and keeps its scoping rules in one place
                 await SettlementService.updateLegacySettlementReference(payment);
-
-                if (STAMHOOFD.environment === 'development') {
-                    console.log('Updated settlement of payment ' + payment.id);
-                    console.log(payment.settlement);
-                }
             } else {
                 console.log('Missing payment ' + mp.paymentId);
             }

package/src/helpers/StripeSettlementSync.test.ts

@@ -662,91 +662,6 @@ describe('StripeSettlementSync', () => {
         expect(after).toEqual(rowIds);
     });
 
-    test('a payment that moved to another payout is swept', async () => {
-        const payment = await createPayment();
-        const otherPayment = await createPayment({ price: 50_00_00 });
-        const payout = stripeMocker.createPayout({ amount: 15000, arrivalDate, stripeAccount: stripeAccount.accountId });
-
-        stripeMocker.createBalanceTransaction({
-            type: 'payment',
-            amount: 10000,
-            created,
-            payout: payout.id,
-            stripeAccount: stripeAccount.accountId,
-            source: stripeMocker.createChargeObject({ metadata: { payment: payment.id } }),
-        });
-        const moved = stripeMocker.createBalanceTransaction({
-            type: 'payment',
-            amount: 5000,
-            created,
-            payout: payout.id,
-            stripeAccount: stripeAccount.accountId,
-            source: stripeMocker.createChargeObject({ metadata: { payment: otherPayment.id } }),
-        });
-
-        const sync = createConnectedSync();
-        expect(await sync.syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
-
-        const settlement = await getSettlement(payout);
-        expect(await PaymentSettlement.select().where('settlementId', settlement.id).count()).toBe(2);
-
-        // Stripe moved the second payment to a later payout
-        moved.payout = stripeMocker.createId('po');
-        payout.amount = 10000;
-
-        expect(await sync.syncPayouts({ start, force: true })).toEqual({ synced: 1, skipped: 0, failed: 0 });
-
-        const lines = await PaymentSettlement.select().where('settlementId', settlement.id).fetch();
-        expect(lines).toHaveLength(1);
-        expect(lines[0].paymentId).toBe(payment.id);
-        expect((await getSettlement(payout)).unexplainedAmount).toBe(0);
-    });
-
-    test('an application fee that moved to another payout is only unlinked', async () => {
-        const payment = await createPayment();
-        const payout = stripeMocker.createPayout({ amount: 250, arrivalDate });
-        const movedFee = stripeMocker.createBalanceTransaction({
-            type: 'application_fee',
-            amount: 250,
-            created,
-            payout: payout.id,
-            source: stripeMocker.createApplicationFee({
-                amount: 250,
-                account: stripeAccount.accountId,
-                originatingTransaction: stripeMocker.createChargeObject({ metadata: { payment: payment.id, serviceFee: '30' } }),
-            }),
-        });
-
-        const sync = createSync();
-        expect(await sync.syncPayouts({ start })).toEqual({ synced: 1, skipped: 0, failed: 0 });
-
-        const settlement = await getSettlement(payout);
-        const applicationFeeId = ((movedFee.source as StripeObject)).id;
-        expect(await ApplicationFee.select().where('settlementId', settlement.id).count()).toBe(2);
-
-        movedFee.payout = stripeMocker.createId('po');
-        payout.amount = 0;
-
-        expect(await sync.syncPayouts({ start, force: true })).toEqual({ synced: 1, skipped: 0, failed: 0 });
-
-        // The fee rows outlive the payout: they are only unlinked, and so are the deduction
-        // charges they point at (a foreign key forbids deleting those)
-        const fees = await ApplicationFee.select().where('externalId', applicationFeeId).fetch();
-        expect(fees).toHaveLength(2);
-        for (const fee of fees) {
-            expect(fee.settlementId).toBeNull();
-        }
-        const deductions = await SettlementCharge.select().where('applicationFeeId', applicationFeeId).fetch();
-        expect(deductions).toHaveLength(2);
-        for (const row of deductions) {
-            expect(row.settlementId).toBeNull();
-        }
-
-        const after = await getSettlement(payout);
-        expect(after.unexplainedAmount).toBe(0);
-        expect(after.pendingFees).toBe(0);
-    });
-
     describe('Payers we can no longer reach', () => {
         /**
          * A platform payout that only receives one application fee, plus the payout transaction.