@fantastic.dev/better-stripe 0.17.0 → 0.18.0

package/src/component/payoutPolicy/helpers.ts

@@ -0,0 +1,88 @@
+import type { Infer } from "convex/values";
+import type { QueryCtx, MutationCtx } from "../_generated/server.js";
+import type { schedule, thresholds } from "./schema.js";
+export function canonicalSchedule(value: Infer<typeof schedule>) {
+  const weekdays = [
+    "monday",
+    "tuesday",
+    "wednesday",
+    "thursday",
+    "friday",
+    "saturday",
+    "sunday",
+  ];
+  if (value.interval === "weekly") {
+    const days = value.weeklyDays;
+    if (
+      !days?.length ||
+      days.length > 7 ||
+      new Set(days).size !== days.length ||
+      days.some((day) => !weekdays.includes(day))
+    )
+      throw new Error("Invalid weekly payout schedule.");
+    return { interval: value.interval, weeklyDays: [...days].sort() };
+  }
+  if (value.interval === "monthly") {
+    const days = value.monthlyDays;
+    if (
+      !days?.length ||
+      days.length > 31 ||
+      new Set(days).size !== days.length ||
+      days.some((day) => !Number.isInteger(day) || day < 1 || day > 31)
+    )
+      throw new Error("Invalid monthly payout schedule.");
+    return {
+      interval: value.interval,
+      monthlyDays: [...days].sort((a, b) => a - b),
+    };
+  }
+  return { interval: value.interval };
+}
+export function canonicalThresholds(
+  values: Infer<typeof thresholds>,
+  custom: boolean,
+) {
+  if (
+    (custom && !values.length) ||
+    values.length > 50 ||
+    (!custom && values.length) ||
+    new Set(values.map((v) => v.currency)).size !== values.length ||
+    values.some(
+      (v) =>
+        !Number.isSafeInteger(v.amount) ||
+        v.amount <= 0 ||
+        !/^[a-z]{3}$/.test(v.currency),
+    )
+  )
+    throw new Error("Invalid custom payout thresholds.");
+  return [...values].sort((a, b) => a.currency.localeCompare(b.currency));
+}
+export function validateScope(scope: { accountId: string; ownerKey: string }) {
+  if (
+    !/^acct_\w+$/.test(scope.accountId) ||
+    scope.accountId.length > 80 ||
+    !scope.ownerKey.trim() ||
+    scope.ownerKey.length > 200
+  )
+    throw new Error("Invalid payout policy identity.");
+}
+export async function readPolicy(
+  ctx: QueryCtx | MutationCtx,
+  scope: { accountId: string; ownerKey: string },
+) {
+  validateScope(scope);
+  const value = await ctx.db
+    .query("payoutPolicies")
+    .withIndex("by_account", (q) => q.eq("accountId", scope.accountId))
+    .unique();
+  if (value && value.ownerKey !== scope.ownerKey)
+    throw new Error("Payout policy owner does not match.");
+  return value;
+}
+export const same = (a: unknown, b: unknown) =>
+  JSON.stringify(a) === JSON.stringify(b);
+export function holdingDays(country: string) {
+  if (!/^[A-Z]{2}$/.test(country))
+    throw new Error("A verified account country is required.");
+  return country === "TH" ? 10 : country === "US" ? 730 : 90;
+}

package/src/component/payoutPolicy/mutations.ts

@@ -0,0 +1,225 @@
+import { v } from "convex/values";
+import { mutation } from "../_generated/server.js";
+import {
+  prepareFields,
+  operationDoc,
+  scopeFields,
+  schedule,
+} from "./schema.js";
+import {
+  canonicalSchedule,
+  canonicalThresholds,
+  readPolicy,
+  holdingDays,
+  same,
+  validateScope,
+} from "./helpers.js";
+export const prepare = mutation({
+  args: prepareFields,
+  returns: operationDoc,
+  handler: async (ctx, input) => {
+    validateScope(input);
+    if (
+      !input.operationKey.trim() ||
+      input.operationKey.length > 180 ||
+      /[\r\n]/.test(input.operationKey) ||
+      !Number.isSafeInteger(input.expectedRevision) ||
+      input.expectedRevision < -1 ||
+      input.expectedRevision >= Number.MAX_SAFE_INTEGER
+    )
+      throw new Error("Invalid payout policy operation identity or revision.");
+    const days = holdingDays(input.country);
+    const args = {
+      ...input,
+      observedSchedule: canonicalSchedule(input.observedSchedule),
+      thresholds: canonicalThresholds(
+        input.thresholds,
+        input.mode === "custom",
+      ),
+    };
+    const old = await ctx.db
+      .query("payoutPolicyOperations")
+      .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+      .unique();
+    if (old) {
+      if (
+        old.accountId !== args.accountId ||
+        old.ownerKey !== args.ownerKey ||
+        old.expectedRevision !== args.expectedRevision ||
+        old.mode !== args.mode ||
+        old.country !== args.country ||
+        old.observedAt !== args.observedAt ||
+        !same(old.thresholds, args.thresholds) ||
+        !same(old.observedSchedule, args.observedSchedule)
+      )
+        throw new Error("Payout policy operation identity cannot be reused.");
+      return old;
+    }
+    if (
+      input.observedAt !== undefined &&
+      (!Number.isSafeInteger(input.observedAt) ||
+        input.observedAt > Date.now() ||
+        input.observedAt < Date.now() - 600000)
+    )
+      throw new Error("Payout policy observation is stale or in the future.");
+    const policy = await readPolicy(ctx, args);
+    if (policy?.status === "changing")
+      throw new Error("A payout policy operation is pending.");
+    if ((policy?.revision ?? -1) !== args.expectedRevision)
+      throw new Error("Payout policy revision changed.");
+    if (
+      policy?.mode === "custom" &&
+      args.observedSchedule.interval !== "manual"
+    )
+      throw new Error("Payout schedule drift requires reconciliation.");
+    if (
+      policy?.mode === "custom" &&
+      policy.country !== args.country &&
+      args.mode === "custom"
+    )
+      throw new Error("Payout policy country changed.");
+    if (
+      args.mode === "custom" &&
+      policy?.mode !== "custom" &&
+      args.observedSchedule.interval === "manual"
+    )
+      throw new Error("An existing manual schedule requires migration.");
+    const previousSchedule =
+      policy?.mode === "custom"
+        ? policy.previousSchedule!
+        : args.observedSchedule;
+    const targetSchedule =
+      args.mode === "custom"
+        ? { interval: "manual" as const }
+        : previousSchedule;
+    const revision = args.expectedRevision + 1;
+    const operationId = await ctx.db.insert("payoutPolicyOperations", {
+      ...args,
+      revision,
+      previousSchedule,
+      targetSchedule,
+      status: "pending",
+    });
+    const next = {
+      accountId: args.accountId,
+      ownerKey: args.ownerKey,
+      revision,
+      mode: policy?.mode ?? ("stripe_managed" as const),
+      thresholds: policy?.thresholds ?? [],
+      status: "changing" as const,
+      operationKey: args.operationKey,
+      country: args.country,
+      previousSchedule,
+      holdDeadline:
+        policy?.holdDeadline ??
+        (args.mode === "custom"
+          ? (args.observedAt ?? Date.now()) + days * 86400000
+          : undefined),
+    };
+    if (policy) await ctx.db.patch("payoutPolicies", policy._id, next);
+    else await ctx.db.insert("payoutPolicies", next);
+    return (await ctx.db.get("payoutPolicyOperations", operationId))!;
+  },
+});
+export const confirm = mutation({
+  args: {
+    ...scopeFields,
+    operationKey: v.string(),
+    observedSchedule: schedule,
+  },
+  returns: operationDoc,
+  handler: async (ctx, args) => {
+    const policy = await readPolicy(ctx, args);
+    const op = await ctx.db
+      .query("payoutPolicyOperations")
+      .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+      .unique();
+    if (!op || op.accountId !== args.accountId || op.ownerKey !== args.ownerKey)
+      throw new Error("Payout policy operation identity does not match.");
+    if (!same(canonicalSchedule(args.observedSchedule), op.targetSchedule))
+      throw new Error("Provider payout schedule was not confirmed.");
+    if (op.status === "complete") return op;
+    if (op.status === "canceled")
+      throw new Error("Payout policy operation was canceled.");
+    if (
+      !policy ||
+      policy.operationKey !== op.operationKey ||
+      policy.revision !== op.revision
+    )
+      throw new Error("Payout policy revision changed.");
+    await ctx.db.patch("payoutPolicyOperations", op._id, {
+      status: "complete",
+    });
+    await ctx.db.patch("payoutPolicies", policy._id, {
+      mode: op.mode,
+      thresholds: op.thresholds,
+      status: "ready",
+      ...(op.mode === "stripe_managed"
+        ? { previousSchedule: undefined, holdDeadline: undefined }
+        : {}),
+    });
+    return (await ctx.db.get("payoutPolicyOperations", op._id))!;
+  },
+});
+export const beginAttempt = mutation({
+  args: { ...scopeFields, operationKey: v.string() },
+  returns: operationDoc,
+  handler: async (ctx, args) => {
+    const policy = await readPolicy(ctx, args);
+    const op = await ctx.db
+      .query("payoutPolicyOperations")
+      .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+      .unique();
+    if (
+      !op ||
+      op.accountId !== args.accountId ||
+      op.ownerKey !== args.ownerKey ||
+      op.status !== "pending" ||
+      policy?.operationKey !== op.operationKey ||
+      policy.status !== "changing"
+    )
+      throw new Error("Payout policy operation is not pending.");
+    if (!op.attempted)
+      await ctx.db.patch("payoutPolicyOperations", op._id, { attempted: true });
+    return (await ctx.db.get("payoutPolicyOperations", op._id))!;
+  },
+});
+export const cancelUnattempted = mutation({
+  args: {
+    ...scopeFields,
+    operationKey: v.string(),
+    observedSchedule: schedule,
+  },
+  returns: operationDoc,
+  handler: async (ctx, args) => {
+    const policy = await readPolicy(ctx, args);
+    const op = await ctx.db
+      .query("payoutPolicyOperations")
+      .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+      .unique();
+    if (
+      !op ||
+      op.accountId !== args.accountId ||
+      op.ownerKey !== args.ownerKey ||
+      op.attempted ||
+      op.status !== "pending" ||
+      policy?.operationKey !== op.operationKey ||
+      policy.status !== "changing"
+    )
+      throw new Error(
+        "An attempted payout policy operation cannot be canceled.",
+      );
+    if (!same(canonicalSchedule(args.observedSchedule), op.observedSchedule))
+      throw new Error("Provider schedule changed before cancellation.");
+    await ctx.db.patch("payoutPolicyOperations", op._id, {
+      status: "canceled",
+    });
+    await ctx.db.patch("payoutPolicies", policy._id, {
+      status: "ready",
+      ...(policy.mode === "stripe_managed"
+        ? { previousSchedule: undefined, holdDeadline: undefined }
+        : {}),
+    });
+    return (await ctx.db.get("payoutPolicyOperations", op._id))!;
+  },
+});

package/src/component/payoutPolicy/queries.ts

@@ -0,0 +1,56 @@
+import { paginationOptsValidator } from "convex/server";
+import { v } from "convex/values";
+import { query } from "../_generated/server.js";
+import { scopeFields, policyDoc, operationDoc } from "./schema.js";
+import { readPolicy, validateScope } from "./helpers.js";
+export const get = query({
+  args: scopeFields,
+  returns: v.union(policyDoc, v.null()),
+  handler: readPolicy,
+});
+export const operation = query({
+  args: { ...scopeFields, operationKey: v.string() },
+  returns: v.union(operationDoc, v.null()),
+  handler: async (ctx, args) => {
+    validateScope(args);
+    const op = await ctx.db
+      .query("payoutPolicyOperations")
+      .withIndex("by_operation", (q) => q.eq("operationKey", args.operationKey))
+      .unique();
+    if (
+      op &&
+      (op.accountId !== args.accountId || op.ownerKey !== args.ownerKey)
+    )
+      throw new Error("Payout policy operation identity does not match.");
+    return op;
+  },
+});
+export const due = query({
+  args: { now: v.number(), paginationOpts: paginationOptsValidator },
+  returns: v.object({
+    page: v.array(policyDoc),
+    continueCursor: v.string(),
+    isDone: v.boolean(),
+  }),
+  handler: async (ctx, args) => {
+    if (
+      !Number.isSafeInteger(args.now) ||
+      args.now < 0 ||
+      !Number.isInteger(args.paginationOpts.numItems) ||
+      args.paginationOpts.numItems < 1 ||
+      args.paginationOpts.numItems > 100
+    )
+      throw new Error("Invalid payout policy due page.");
+    const page = await ctx.db
+      .query("payoutPolicies")
+      .withIndex("by_deadline", (q) =>
+        q.gt("holdDeadline", 0).lte("holdDeadline", args.now),
+      )
+      .paginate(args.paginationOpts);
+    return {
+      page: page.page,
+      continueCursor: page.continueCursor,
+      isDone: page.isDone,
+    };
+  },
+});

package/src/component/payoutPolicy/schema.ts

@@ -0,0 +1,67 @@
+import { defineTable } from "convex/server";
+import { v } from "convex/values";
+export const scopeFields = { accountId: v.string(), ownerKey: v.string() };
+export const schedule = v.object({
+  interval: v.union(
+    v.literal("daily"),
+    v.literal("weekly"),
+    v.literal("monthly"),
+    v.literal("manual"),
+  ),
+  weeklyDays: v.optional(v.array(v.string())),
+  monthlyDays: v.optional(v.array(v.number())),
+});
+export const mode = v.union(v.literal("stripe_managed"), v.literal("custom"));
+export const thresholds = v.array(
+  v.object({ currency: v.string(), amount: v.number() }),
+);
+export const prepareFields = {
+  ...scopeFields,
+  operationKey: v.string(),
+  expectedRevision: v.number(),
+  mode,
+  thresholds,
+  country: v.string(),
+  observedSchedule: schedule,
+  observedAt: v.optional(v.number()),
+};
+export const policyFields = {
+  ...scopeFields,
+  revision: v.number(),
+  mode,
+  thresholds,
+  status: v.union(v.literal("changing"), v.literal("ready")),
+  operationKey: v.string(),
+  country: v.string(),
+  previousSchedule: v.optional(schedule),
+  holdDeadline: v.optional(v.number()),
+};
+export const operationFields = {
+  ...prepareFields,
+  revision: v.number(),
+  previousSchedule: schedule,
+  targetSchedule: schedule,
+  status: v.union(
+    v.literal("pending"),
+    v.literal("complete"),
+    v.literal("canceled"),
+  ),
+  attempted: v.optional(v.boolean()),
+};
+export const policyDoc = v.object({
+  ...policyFields,
+  _id: v.id("payoutPolicies"),
+  _creationTime: v.number(),
+});
+export const operationDoc = v.object({
+  ...operationFields,
+  _id: v.id("payoutPolicyOperations"),
+  _creationTime: v.number(),
+});
+export const policiesTable = defineTable(policyFields)
+  .index("by_account", ["accountId"])
+  .index("by_deadline", ["holdDeadline"]);
+export const operationsTable = defineTable(operationFields).index(
+  "by_operation",
+  ["operationKey"],
+);

package/src/component/schema.ts

@@ -1,3 +1,4 @@
+import { policiesTable, operationsTable } from "./payoutPolicy/schema.js";
 import { currencyTotalsTable } from "./earnings/schema.js";
 import {
   claimsTable,
@@ -31,6 +32,8 @@ import { pricesTable, productsTable } from "./products/schema";
 import { webhookEventsTable } from "./webhooks/schema";
 
 export default defineSchema({
+  payoutPolicies: policiesTable,
+  payoutPolicyOperations: operationsTable,
   currencyTotals: currencyTotalsTable,
   recoveryClaims: claimsTable,
   recoveryBalances: balancesTable,

package/src/component/summary-arithmetic.test.ts

@@ -0,0 +1,246 @@
+import { convexTest } from "convex-test";
+import { expect, it } from "vitest";
+
+import { api } from "./_generated/api.js";
+import schema from "./schema.js";
+
+const modules = import.meta.glob("./**/*.*s");
+const max = Number.MAX_SAFE_INTEGER;
+const transfer = (stripeTransferId: string, amount: number) => ({
+  stripeTransferId,
+  amount,
+  destinationAccountId: "acct_a",
+  currency: "usd",
+  status: "paid" as const,
+});
+const payout = (stripePayoutId: string, amount: number) => ({
+  stripePayoutId,
+  amount,
+  accountId: "acct_a",
+  currency: "usd",
+  status: "paid" as const,
+});
+const earnings = { destinationAccountId: "acct_a", previewLimit: 0 };
+
+it("rejects the public artifact overflow before rounding and rolls back each rejected transfer", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(
+    api.connect.mutations.upsertTransfer,
+    transfer("tr_max", max),
+  );
+  const original = await t.query(
+    api.connect.queries.getAccountEarningsByCurrency,
+    earnings,
+  );
+  for (const id of ["tr_overflow_1", "tr_overflow_2"])
+    await expect(
+      t.mutation(api.connect.mutations.upsertTransfer, transfer(id, 1)),
+    ).rejects.toThrow(/safe integer/i);
+  expect(
+    await t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+  ).toEqual(original);
+  expect(await t.run((ctx) => ctx.db.query("transfers").take(3))).toHaveLength(
+    1,
+  );
+});
+
+it("rejects paid payout overflow without persisting the payout or changing its summary", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(api.connect.mutations.upsertPayout, payout("po_max", max));
+  await expect(
+    t.mutation(api.connect.mutations.upsertPayout, payout("po_overflow", 1)),
+  ).rejects.toThrow(/safe integer/i);
+  expect(
+    await t.query(api.connect.queries.getAccountPayoutsByCurrency, {
+      accountId: "acct_a",
+      previewLimit: 0,
+    }),
+  ).toMatchObject({ totals: [{ paidOut: max, payoutCount: 1 }] });
+  expect(await t.run((ctx) => ctx.db.query("payouts").take(2))).toHaveLength(1);
+});
+
+it.each([0.5, Number.NaN, Number.POSITIVE_INFINITY, max + 1])(
+  "rejects invalid source amounts %s, including unpaid payouts",
+  async (amount) => {
+    const t = convexTest(schema, modules);
+    await expect(
+      t.mutation(
+        api.connect.mutations.upsertTransfer,
+        transfer("tr_invalid", amount),
+      ),
+    ).rejects.toThrow(/safe integer/i);
+    await expect(
+      t.mutation(api.connect.mutations.upsertPayout, {
+        ...payout("po_invalid", amount),
+        status: "pending",
+      }),
+    ).rejects.toThrow(/safe integer/i);
+    expect(
+      await t.run((ctx) => ctx.db.query("currencyTotals").take(1)),
+    ).toEqual([]);
+  },
+);
+
+it("rolls back subtract/reapply updates that would overflow", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(
+    api.connect.mutations.upsertTransfer,
+    transfer("tr_max", max),
+  );
+  await t.mutation(
+    api.connect.mutations.upsertTransfer,
+    transfer("tr_update", 0),
+  );
+  const before = await t.run((ctx) => ctx.db.query("transfers").take(3));
+  await expect(
+    t.mutation(api.connect.mutations.upsertTransfer, transfer("tr_update", 1)),
+  ).rejects.toThrow(/safe integer/i);
+  expect(await t.run((ctx) => ctx.db.query("transfers").take(3))).toEqual(
+    before,
+  );
+  expect(
+    await t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+  ).toMatchObject({ totals: [{ gross: max, transferCount: 2 }] });
+});
+
+it("rolls back a reversal whose cumulative summary would overflow", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(api.connect.mutations.upsertTransfer, {
+    ...transfer("tr_a", 1),
+    reversedAmount: max - 1,
+  });
+  await t.mutation(api.connect.mutations.upsertTransfer, {
+    ...transfer("tr_b", 1),
+    reversedAmount: 1,
+  });
+  const before = await t.query(
+    api.connect.queries.getAccountEarningsByCurrency,
+    earnings,
+  );
+  await expect(
+    t.mutation(api.connect.mutations.recordTransferReversal, {
+      stripeTransferId: "tr_b",
+      reversedAmount: 2,
+    }),
+  ).rejects.toThrow(/safe integer/i);
+  expect(
+    await t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+  ).toEqual(before);
+});
+
+it.each(["earnings", "payouts"] as const)(
+  "rolls back an entire %s backfill page and source markers on unsafe totals",
+  async (kind) => {
+    const t = convexTest(schema, modules);
+    await t.run(async (ctx) => {
+      if (kind === "earnings") {
+        await ctx.db.insert("transfers", transfer("tr_legacy_max", max));
+        await ctx.db.insert("transfers", transfer("tr_legacy_overflow", 1));
+      } else {
+        await ctx.db.insert("payouts", payout("po_legacy_max", max));
+        await ctx.db.insert("payouts", payout("po_legacy_overflow", 1));
+      }
+    });
+    await expect(
+      t.mutation(api.earnings.mutations.backfillCurrencyTotals, {
+        kind,
+        cursor: null,
+      }),
+    ).rejects.toThrow(/safe integer/i);
+    expect(
+      await t.run((ctx) => ctx.db.query("currencyTotals").take(1)),
+    ).toEqual([]);
+    expect(
+      (
+        await t.run((ctx) =>
+          ctx.db.query(kind === "earnings" ? "transfers" : "payouts").take(2),
+        )
+      ).every((row) => row.totalsRecorded === undefined),
+    ).toBe(true);
+  },
+);
+
+it.each([
+  ["gross", max + 1],
+  ["reversed", 0.5],
+  ["paidOut", Number.POSITIVE_INFINITY],
+  ["count", Number.NaN],
+] as const)(
+  "rejects unsafe stored summary field %s before exposing totals",
+  async (field, value) => {
+    const t = convexTest(schema, modules);
+    await t.run((ctx) =>
+      ctx.db.insert("currencyTotals", {
+        accountId: "acct_a",
+        currency: "usd",
+        kind: "earnings",
+        gross: 100,
+        reversed: 0,
+        paidOut: 0,
+        count: 1,
+        [field]: value,
+      }),
+    );
+    await expect(
+      t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+    ).rejects.toThrow(/safe integer/i);
+  },
+);
+
+it("checks summary counts before persisting a new source record", async () => {
+  const t = convexTest(schema, modules);
+  await t.run((ctx) =>
+    ctx.db.insert("currencyTotals", {
+      accountId: "acct_a",
+      currency: "usd",
+      kind: "earnings",
+      gross: 0,
+      reversed: 0,
+      paidOut: 0,
+      count: max,
+    }),
+  );
+  await expect(
+    t.mutation(api.connect.mutations.upsertTransfer, transfer("tr_count", 0)),
+  ).rejects.toThrow(/safe integer/i);
+  expect(await t.run((ctx) => ctx.db.query("transfers").take(1))).toEqual([]);
+});
+
+it("rejects an unsafe derived net even when both stored operands are safe integers", async () => {
+  const t = convexTest(schema, modules);
+  await t.run((ctx) =>
+    ctx.db.insert("currencyTotals", {
+      accountId: "acct_a",
+      currency: "usd",
+      kind: "earnings",
+      gross: max,
+      reversed: -1,
+      paidOut: 0,
+      count: 1,
+    }),
+  );
+  await expect(
+    t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+  ).rejects.toThrow(/safe integer/i);
+});
+
+it("preserves supported boundary amounts through reversal and reinstatement", async () => {
+  const t = convexTest(schema, modules);
+  await t.mutation(
+    api.connect.mutations.upsertTransfer,
+    transfer("tr_boundary", max - 2),
+  );
+  await t.mutation(api.connect.mutations.recordTransferReversal, {
+    stripeTransferId: "tr_boundary",
+    reversedAmount: 1,
+  });
+  await t.mutation(api.connect.mutations.upsertTransfer, {
+    ...transfer("tr_restore", 1),
+    reinstatement: true,
+  });
+  expect(
+    await t.query(api.connect.queries.getAccountEarningsByCurrency, earnings),
+  ).toMatchObject({
+    totals: [{ gross: max - 1, reversed: 1, net: max - 2, transferCount: 2 }],
+  });
+});