Determenistic penny distribution

prisma/seed.ts

@@ -44,18 +44,21 @@ const idLookup: string[] = [];
 
 async function createExpenses() {
   for (let i = 0; i < dummyData.expenses.length; i++) {
-    const { splitShares, ...expense } = dummyData.expenses[i]!;
+    const { splitShares, amount, paidBy, participants, splitType, ...expense } =
+      dummyData.expenses[i]!;
     const res = await createExpense(
       {
         ...expense,
-        paidBy: expense.paidBy.id,
-        participants: calculateParticipantSplit(
-          expense.amount,
-          expense.participants as Participant[],
-          expense.splitType,
+        paidBy: paidBy.id,
+        amount,
+        splitType,
+        participants: calculateParticipantSplit({
+          amount,
+          participants,
+          splitType,
           splitShares,
-          expense.paidBy as Participant,
-        ).participants.map((p) => ({
+          paidBy,
+        } as any).participants.map((p) => ({
           userId: p.id,
           amount: p.amount ?? 0n,
         })),
@@ -77,20 +80,23 @@ async function createExpenses() {
 
 async function editExpenses() {
   for (let i = 0; i < dummyData.expenseEdits.length; i++) {
-    const { splitShares, idx, ...expense } = dummyData.expenseEdits[i]!;
+    const { splitShares, idx, amount, paidBy, participants, splitType, ...expense } =
+      dummyData.expenseEdits[i]!;
     assert(idLookup[idx], `No expense ID found for index ${idx}`);
     await editExpense(
       {
         ...expense,
         expenseId: idLookup[idx]!,
-        paidBy: expense.paidBy.id,
-        participants: calculateParticipantSplit(
-          expense.amount,
-          expense.participants as Participant[],
-          expense.splitType,
+        paidBy: paidBy.id,
+        amount,
+        splitType,
+        participants: calculateParticipantSplit({
+          amount,
+          participants,
+          splitType,
           splitShares,
-          expense.paidBy as Participant,
-        ).participants.map((p) => ({
+          paidBy,
+        } as any).participants.map((p) => ({
           userId: p.id,
           amount: p.amount ?? 0n,
         })),

src/store/addStore.ts

@@ -7,6 +7,7 @@ import { type CurrencyCode } from '~/lib/currency';
 import type { TransactionAddInputModel } from '~/types';
 import { shuffleArray } from '~/utils/array';
 import { BigMath } from '~/utils/numbers';
+import { cyrb128, splitmix32 } from '~/utils/random';
 
 export type Participant = User & { amount?: bigint };
 export type SplitShares = Record<number, Record<SplitType, bigint | undefined>>;
@@ -95,30 +96,10 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
       set((s) => {
         const isNegative = realAmount < 0n;
         const amount = BigMath.abs(realAmount);
-        return {
-          amount,
-          isNegative,
-          ...calculateParticipantSplit(
-            amount,
-            s.participants,
-            s.splitType,
-            s.splitShares,
-            s.paidBy,
-          ),
-        };
+        return calculateParticipantSplit({ ...s, isNegative, amount });
       }),
     setAmountStr: (amountStr) => set({ amountStr }),
-    setSplitType: (splitType) =>
-      set((state) => ({
-        splitType,
-        ...calculateParticipantSplit(
-          state.amount,
-          state.participants,
-          splitType,
-          state.splitShares,
-          state.paidBy,
-        ),
-      })),
+    setSplitType: (splitType) => set((state) => calculateParticipantSplit({ ...state, splitType })),
     setSplitShare: (splitType, userId, share) =>
       set((state) => {
         const splitShares: SplitShares = {
@@ -129,16 +110,7 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
           },
         } as SplitShares;
 
-        return {
-          ...calculateParticipantSplit(
-            state.amount,
-            state.participants,
-            state.splitType,
-            splitShares,
-            state.paidBy,
-          ),
-          splitShares,
-        };
+        return calculateParticipantSplit({ ...state, splitShares });
       }),
     setGroup: (group) => {
       set({ group });
@@ -154,16 +126,7 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
           participants.push({ ...user });
           splitShares[user.id] = initSplitShares();
         }
-        return {
-          splitShares,
-          ...calculateParticipantSplit(
-            state.amount,
-            participants,
-            state.splitType,
-            splitShares,
-            state.paidBy,
-          ),
-        };
+        return calculateParticipantSplit({ ...state, participants, splitShares });
       }),
     setParticipants: (participants, splitType) =>
       set((state) => {
@@ -182,17 +145,7 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
         } else {
           splitType = SplitType.EQUAL;
         }
-        return {
-          splitType,
-          splitShares,
-          ...calculateParticipantSplit(
-            state.amount,
-            participants,
-            splitType,
-            splitShares,
-            state.paidBy,
-          ),
-        };
+        return calculateParticipantSplit({ ...state, participants, splitType, splitShares });
       }),
     removeLastParticipant: () => {
       set((state) => {
@@ -208,16 +161,11 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
         const newParticipants = [...state.participants];
         const { id } = newParticipants.pop()!;
         const { [id]: _, ...rest } = state.splitShares;
-        return {
-          ...calculateParticipantSplit(
-            state.amount,
-            newParticipants,
-            state.splitType,
-            rest,
-            state.paidBy,
-          ),
+        return calculateParticipantSplit({
+          ...state,
+          participants: newParticipants,
           splitShares: rest,
-        };
+        });
       });
     },
     removeParticipant: (userId) => {
@@ -230,26 +178,17 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
 
         const newParticipants = state.participants.filter((p) => p.id !== userId);
         const { [userId]: _, ...rest } = state.splitShares;
-        return {
-          ...calculateParticipantSplit(
-            state.amount,
-            newParticipants,
-            state.splitType,
-            rest,
-            state.paidBy,
-          ),
+        return calculateParticipantSplit({
+          ...state,
+          participants: newParticipants,
           splitShares: rest,
-        };
+        });
       });
     },
     setCurrency: (currency) => set({ currency }),
     setCategory: (category) => set({ category }),
     setNameOrEmail: (nameOrEmail) => set({ nameOrEmail, showFriends: 0 < nameOrEmail.length }),
-    setPaidBy: (paidBy) =>
-      set((s) => ({
-        paidBy,
-        ...calculateParticipantSplit(s.amount, s.participants, s.splitType, s.splitShares, paidBy),
-      })),
+    setPaidBy: (paidBy) => set((state) => calculateParticipantSplit({ ...state, paidBy })),
     setCurrentUser: (currentUser) =>
       set((s) => {
         const cUser = s.participants.find((p) => p.id === currentUser.id);
@@ -299,16 +238,11 @@ export const useAddExpenseStore = create<AddExpenseState>()((set) => ({
   },
 }));
 
-export function calculateParticipantSplit(
-  amount: bigint,
-  participants: Participant[],
-  splitType: SplitType,
-  splitShares: SplitShares,
-  paidBy?: Participant,
-) {
+export function calculateParticipantSplit(state: AddExpenseState) {
+  const { amount, participants, splitType, splitShares, paidBy, expenseDate } = state;
   let canSplitScreenClosed = true;
   if (0n === amount) {
-    return { participants, canSplitScreenClosed };
+    return { ...state, canSplitScreenClosed };
   }
 
   let updatedParticipants = participants;
@@ -374,9 +308,17 @@ export function calculateParticipantSplit(
   if (canSplitScreenClosed) {
     let penniesLeft = updatedParticipants.reduce((acc, p) => acc + (p.amount ?? 0n), 0n);
     const participantsToPick = updatedParticipants.filter((p) => p.amount);
+    const seed =
+      cyrb128(
+        `${participantsToPick
+          .map((p) => p.amount)
+          .toSorted((a, b) => Number((a ?? 0n) - (b ?? 0n)))
+          .join('-')}-${new Intl.DateTimeFormat('en').format(expenseDate)}`,
+      )[0] ?? 0;
+    const random = splitmix32(seed);
 
     if (0 < participantsToPick.length) {
-      shuffleArray(participantsToPick);
+      shuffleArray(participantsToPick, random);
       let i = 0;
       while (0n !== penniesLeft) {
         const p = participantsToPick[i % participantsToPick.length]!;
@@ -387,7 +329,7 @@ export function calculateParticipantSplit(
     }
   }
 
-  return { participants: updatedParticipants, canSplitScreenClosed };
+  return { ...state, participants: updatedParticipants, canSplitScreenClosed };
 }
 
 export const initSplitShares = (): Record<SplitType, undefined> =>