tapimo 0.14.0 → 0.15.0

package/dist/internal/rewards/Projection.js

@@ -0,0 +1,616 @@
+import { getAddress, keccak256, stringToHex, zeroAddress } from 'viem';
+const rateScale = 10000n;
+const secondsPerYear = 365n * 24n * 60n * 60n;
+const sharePriceScale = 10n ** 18n;
+/** Returns a deterministic checksum for a run's complete closing account state. */
+export function checksum(accounts) {
+    return keccak256(stringToHex(JSON.stringify([...accounts].sort(compareAccounts).map((account) => ({
+        accrualRemainder: account.accrualRemainder.toString(),
+        allocatedPrincipalAssets: account.allocatedPrincipalAssets.toString(),
+        cumulativeEntitlement: account.cumulativeEntitlement.toString(),
+        cumulativePaid: account.cumulativePaid.toString(),
+        deferral: account.deferral ?? null,
+        eligibilityRegisteredAt: account.eligibilityRegisteredAt ?? null,
+        lots: account.lots,
+        pendingRewardAssets: account.pendingRewardAssets.toString(),
+        publicEarnShares: account.publicEarnShares.toString(),
+        qualifiedEarnShares: account.qualifiedEarnShares.toString(),
+        recipient: account.recipient.toLowerCase(),
+        registrationOrder: account.registrationOrder.toString(),
+    })))));
+}
+/** Restores one calculation projection from a durable run snapshot. */
+export function fromSnapshot(snapshot) {
+    return {
+        accrualRemainder: BigInt(snapshot.accrualRemainder),
+        allocatedPrincipalAssets: BigInt(snapshot.allocatedPrincipalAssets),
+        cumulativeEntitlement: BigInt(snapshot.cumulativeEntitlement),
+        cumulativePaid: BigInt(snapshot.cumulativePaid),
+        ...(snapshot.deferral ? { deferral: snapshot.deferral } : {}),
+        ...(snapshot.eligibilityRegisteredAt
+            ? { eligibilityRegisteredAt: snapshot.eligibilityRegisteredAt }
+            : {}),
+        lots: [],
+        pendingRewardAssets: BigInt(snapshot.pendingRewardAssets),
+        publicEarnShares: BigInt(snapshot.publicEarnShares),
+        qualifiedEarnShares: BigInt(snapshot.qualifiedEarnShares),
+        recipient: getAddress(snapshot.recipient),
+        registrationOrder: BigInt(snapshot.registrationOrder),
+    };
+}
+/** Serializes one calculation projection for crash-safe run recovery. */
+export function snapshot(account) {
+    return {
+        accrualRemainder: account.accrualRemainder.toString(),
+        allocatedPrincipalAssets: account.allocatedPrincipalAssets.toString(),
+        cumulativeEntitlement: account.cumulativeEntitlement.toString(),
+        cumulativePaid: account.cumulativePaid.toString(),
+        deferral: account.deferral ?? null,
+        eligibilityRegisteredAt: account.eligibilityRegisteredAt ?? null,
+        lots: [],
+        pendingRewardAssets: account.pendingRewardAssets.toString(),
+        publicEarnShares: account.publicEarnShares.toString(),
+        qualifiedEarnShares: account.qualifiedEarnShares.toString(),
+        recipient: account.recipient,
+        registrationOrder: account.registrationOrder.toString(),
+    };
+}
+/** Applies ordered public events and campaign cap allocation to registered accounts. */
+export function apply(options) {
+    const result = applyEvents(options, send);
+    return {
+        ...result,
+        accounts: result.accounts.map((account) => ({ ...account, lots: [] })),
+    };
+}
+function applyEvents(options, sendAccount) {
+    const accounts = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), clone(account)]));
+    const eligible = new Map(options.eligible.map((entry) => [entry.recipient.toLowerCase(), entry.registrationOrder]));
+    const excluded = new Set(options.excluded.map((address) => address.toLowerCase()));
+    for (const [recipient] of eligible)
+        account(accounts, eligible, excluded, getAddress(recipient));
+    let allocated = [...accounts.values()].reduce((sum, account) => sum + account.allocatedPrincipalAssets, 0n);
+    const events = [...options.events].sort(compareEvents);
+    for (const event of events) {
+        if (event.kind === 'transfer') {
+            if (sameAddress(event.from, event.to))
+                continue;
+            if (event.from.toLowerCase() !== zeroAddress) {
+                const sender = accounts.get(event.from.toLowerCase());
+                if (sender)
+                    sendAccount(sender, event.amount);
+            }
+            if (event.to.toLowerCase() !== zeroAddress) {
+                const recipient = account(accounts, eligible, excluded, event.to);
+                if (recipient)
+                    recipient.publicEarnShares += event.amount;
+            }
+            continue;
+        }
+        const recipient = account(accounts, eligible, excluded, event.recipient);
+        if (!recipient || event.assets === 0n || event.earnShares === 0n)
+            continue;
+        const userRemaining = maximum(options.perUserPrincipalCapAssets - recipient.allocatedPrincipalAssets, 0n);
+        const campaignRemaining = maximum(options.totalPrincipalCapAssets - allocated, 0n);
+        const allocatedAssets = minimum(event.assets, userRemaining, campaignRemaining);
+        if (allocatedAssets === 0n)
+            continue;
+        const qualifiedShares = (event.earnShares * allocatedAssets) / event.assets;
+        if (qualifiedShares === 0n)
+            continue;
+        recipient.allocatedPrincipalAssets += allocatedAssets;
+        recipient.qualifiedEarnShares += qualifiedShares;
+        recipient.lots.push({
+            allocatedPrincipalAssets: allocatedAssets.toString(),
+            depositedAssets: event.assets.toString(),
+            depositedEarnShares: event.earnShares.toString(),
+            event: event.cursor,
+            remainingEarnShares: qualifiedShares.toString(),
+        });
+        allocated += allocatedAssets;
+    }
+    return {
+        accounts: [...accounts.values()].sort(compareAccounts),
+        allocatedPrincipalAssets: allocated,
+    };
+}
+/** Reconstructs surviving pre-campaign deposit lots before permanently allocating campaign caps. */
+export function bootstrap(options) {
+    const unlimited = (1n << 256n) - 1n;
+    const replayed = applyEvents({
+        accounts: [],
+        eligible: options.eligible,
+        events: options.events,
+        excluded: options.excluded,
+        perUserPrincipalCapAssets: unlimited,
+        totalPrincipalCapAssets: unlimited,
+    }, sendLots);
+    return allocateBootstrap(replayed.accounts, options);
+}
+function allocateBootstrap(replayed, options) {
+    const accounts = replayed.map((source) => ({
+        ...clone(source),
+        allocatedPrincipalAssets: 0n,
+        lots: [],
+        qualifiedEarnShares: 0n,
+    }));
+    const byRecipient = new Map(accounts.map((entry) => [entry.recipient.toLowerCase(), entry]));
+    let allocated = 0n;
+    const lots = replayed
+        .flatMap((entry) => entry.lots.map((lot) => ({ lot, recipient: entry.recipient })))
+        .sort((left, right) => {
+        if (options.principalAllocationOrder === 'registration') {
+            const order = byRecipient.get(left.recipient.toLowerCase()).registrationOrder -
+                byRecipient.get(right.recipient.toLowerCase()).registrationOrder;
+            if (order !== 0n)
+                return order < 0n ? -1 : 1;
+        }
+        return compareCursors(left.lot.event, right.lot.event);
+    });
+    for (const { lot, recipient } of lots) {
+        const account = byRecipient.get(recipient.toLowerCase());
+        const remainingEarnShares = BigInt(lot.remainingEarnShares);
+        const depositedEarnShares = BigInt(lot.depositedEarnShares);
+        const survivingPrincipalAssets = depositedEarnShares === 0n
+            ? 0n
+            : (BigInt(lot.depositedAssets) * remainingEarnShares) / depositedEarnShares;
+        const userRemaining = maximum(options.perUserPrincipalCapAssets - account.allocatedPrincipalAssets, 0n);
+        const campaignRemaining = maximum(options.totalPrincipalCapAssets - allocated, 0n);
+        const allocatedPrincipalAssets = minimum(survivingPrincipalAssets, userRemaining, campaignRemaining);
+        if (allocatedPrincipalAssets === 0n || survivingPrincipalAssets === 0n)
+            continue;
+        const qualifiedEarnShares = (remainingEarnShares * allocatedPrincipalAssets) / survivingPrincipalAssets;
+        if (qualifiedEarnShares === 0n)
+            continue;
+        account.allocatedPrincipalAssets += allocatedPrincipalAssets;
+        account.qualifiedEarnShares += qualifiedEarnShares;
+        allocated += allocatedPrincipalAssets;
+    }
+    return { accounts: accounts.sort(compareAccounts), allocatedPrincipalAssets: allocated };
+}
+/** Reconciles registration history pagewise and checkpoints replay state without retaining events. */
+export async function reconcilePages(options) {
+    const current = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), account]));
+    const pending = new Map(options.eligible
+        .filter((entry) => {
+        const account = current.get(entry.recipient.toLowerCase());
+        return account?.eligibilityRegisteredAt !== entry.registeredAt;
+    })
+        .map((entry) => [entry.recipient.toLowerCase(), entry]));
+    if (pending.size === 0)
+        return { accounts: options.accounts, reconciled: false };
+    const replay = new Map([...pending].filter(([recipient]) => {
+        const account = current.get(recipient);
+        return (!account ||
+            (account.allocatedPrincipalAssets === 0n &&
+                account.lots.length === 0 &&
+                account.qualifiedEarnShares === 0n));
+    }));
+    const retained = options.accounts.filter((account) => !replay.has(account.recipient.toLowerCase()));
+    const retainedAllocated = retained.reduce((sum, account) => sum + account.allocatedPrincipalAssets, 0n);
+    let replayed = options.checkpoint
+        ? options.checkpoint.accounts.map(fromSnapshot)
+        : apply({
+            accounts: [],
+            eligible: [...replay.values()].map((entry) => ({
+                recipient: entry.recipient,
+                registrationOrder: entry.registrationOrder,
+            })),
+            events: [],
+            excluded: options.excluded,
+            perUserPrincipalCapAssets: 0n,
+            totalPrincipalCapAssets: 0n,
+        }).accounts;
+    const depositedEarnShares = new Map(Object.entries(options.checkpoint?.depositedEarnShares ?? {}).map(([recipient, value]) => [
+        recipient,
+        BigInt(value),
+    ]));
+    let replayedThrough = options.checkpoint?.replayedThrough;
+    if (!options.checkpoint || options.checkpoint.pass === 'survival')
+        for await (const page of options.pages('survival', options.checkpoint?.cursor)) {
+            const { events } = page;
+            const accounts = new Map(replayed.map((entry) => [entry.recipient.toLowerCase(), entry]));
+            const eligible = new Map([...replay].map(([recipient, entry]) => [recipient, entry.registrationOrder]));
+            const excluded = new Set(options.excluded.map((address) => address.toLowerCase()));
+            for (const event of [...events].sort(compareEvents)) {
+                if (event.kind === 'deposit') {
+                    const recipient = account(accounts, eligible, excluded, event.recipient);
+                    if (!recipient || event.assets === 0n || event.earnShares === 0n)
+                        continue;
+                    const key = recipient.recipient.toLowerCase();
+                    depositedEarnShares.set(key, (depositedEarnShares.get(key) ?? 0n) + event.earnShares);
+                    recipient.qualifiedEarnShares += event.earnShares;
+                    continue;
+                }
+                if (sameAddress(event.from, event.to))
+                    continue;
+                if (event.from.toLowerCase() !== zeroAddress) {
+                    const sender = accounts.get(event.from.toLowerCase());
+                    if (sender)
+                        send(sender, event.amount);
+                }
+                if (event.to.toLowerCase() !== zeroAddress) {
+                    const recipient = account(accounts, eligible, excluded, event.to);
+                    if (recipient)
+                        recipient.publicEarnShares += event.amount;
+                }
+            }
+            replayed = [...accounts.values()].sort(compareAccounts);
+            const cursor = events.at(-1)?.cursor;
+            if (cursor) {
+                replayedThrough = cursor;
+                await options.checkpointState?.({
+                    accounts: replayed.map(snapshot),
+                    cursor,
+                    depositedEarnShares: Object.fromEntries([...depositedEarnShares].map(([recipient, value]) => [recipient, value.toString()])),
+                    pass: 'survival',
+                    replayedThrough,
+                });
+            }
+        }
+    let initialized = options.checkpoint?.pass === 'allocation'
+        ? options.checkpoint.accounts.map(fromSnapshot)
+        : replayed.map((entry) => ({
+            ...entry,
+            allocatedPrincipalAssets: 0n,
+            lots: [],
+            qualifiedEarnShares: 0n,
+        }));
+    const consumedEarnShares = new Map(options.checkpoint?.pass === 'allocation'
+        ? Object.entries(options.checkpoint.consumedEarnShares ?? {}).map(([recipient, value]) => [
+            recipient,
+            BigInt(value),
+        ])
+        : replayed.map((entry) => [
+            entry.recipient.toLowerCase(),
+            (depositedEarnShares.get(entry.recipient.toLowerCase()) ?? 0n) -
+                entry.qualifiedEarnShares,
+        ]));
+    let allocated = retainedAllocated + initialized.reduce((sum, entry) => sum + entry.allocatedPrincipalAssets, 0n);
+    for await (const page of options.pages('allocation', options.checkpoint?.pass === 'allocation' ? options.checkpoint.cursor : undefined)) {
+        const { events } = page;
+        const accounts = new Map(initialized.map((entry) => [entry.recipient.toLowerCase(), entry]));
+        for (const event of events) {
+            if (event.kind !== 'deposit')
+                continue;
+            const recipient = accounts.get(event.recipient.toLowerCase());
+            if (!recipient || event.assets === 0n || event.earnShares === 0n)
+                continue;
+            const key = recipient.recipient.toLowerCase();
+            const consumed = minimum(consumedEarnShares.get(key) ?? 0n, event.earnShares);
+            consumedEarnShares.set(key, (consumedEarnShares.get(key) ?? 0n) - consumed);
+            const remainingEarnShares = event.earnShares - consumed;
+            const survivingPrincipalAssets = (event.assets * remainingEarnShares) / event.earnShares;
+            const allocatedPrincipalAssets = minimum(survivingPrincipalAssets, maximum(options.perUserPrincipalCapAssets - recipient.allocatedPrincipalAssets, 0n), maximum(options.totalPrincipalCapAssets - allocated, 0n));
+            if (allocatedPrincipalAssets === 0n || survivingPrincipalAssets === 0n)
+                continue;
+            const qualifiedEarnShares = (remainingEarnShares * allocatedPrincipalAssets) / survivingPrincipalAssets;
+            if (qualifiedEarnShares === 0n)
+                continue;
+            recipient.allocatedPrincipalAssets += allocatedPrincipalAssets;
+            recipient.qualifiedEarnShares += qualifiedEarnShares;
+            allocated += allocatedPrincipalAssets;
+        }
+        initialized = [...accounts.values()].sort(compareAccounts);
+        const cursor = events.at(-1)?.cursor;
+        if (cursor || page.allocationRecipient)
+            await options.checkpointState?.({
+                ...(page.allocationRecipient ? { allocationRecipient: page.allocationRecipient } : {}),
+                accounts: initialized.map(snapshot),
+                consumedEarnShares: Object.fromEntries([...consumedEarnShares].map(([recipient, value]) => [recipient, value.toString()])),
+                ...(cursor ? { cursor } : {}),
+                depositedEarnShares: Object.fromEntries([...depositedEarnShares].map(([recipient, value]) => [recipient, value.toString()])),
+                pass: 'allocation',
+                ...(replayedThrough ? { replayedThrough } : {}),
+            });
+    }
+    return {
+        accounts: [
+            ...retained.map((account) => {
+                const entry = pending.get(account.recipient.toLowerCase());
+                return entry ? { ...account, eligibilityRegisteredAt: entry.registeredAt } : account;
+            }),
+            ...initialized.map((account) => {
+                const entry = pending.get(account.recipient.toLowerCase());
+                const previous = current.get(account.recipient.toLowerCase());
+                return {
+                    ...account,
+                    accrualRemainder: previous?.accrualRemainder ?? 0n,
+                    cumulativeEntitlement: previous?.cumulativeEntitlement ?? 0n,
+                    cumulativePaid: previous?.cumulativePaid ?? 0n,
+                    ...(previous?.deferral ? { deferral: previous.deferral } : {}),
+                    eligibilityRegisteredAt: entry.registeredAt,
+                    pendingRewardAssets: previous?.pendingRewardAssets ?? 0n,
+                };
+            }),
+        ].sort(compareAccounts),
+        reconciled: true,
+    };
+}
+/** Rebuilds deposit-derived state for new or refreshed eligibility registrations. */
+export function reconcileRegistrations(options) {
+    const accounts = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), account]));
+    const pending = new Map(options.eligible
+        .filter((entry) => {
+        const account = accounts.get(entry.recipient.toLowerCase());
+        return account?.eligibilityRegisteredAt !== entry.registeredAt;
+    })
+        .map((entry) => [entry.recipient.toLowerCase(), entry]));
+    if (pending.size === 0)
+        return { accounts: options.accounts, reconciled: false };
+    // Principal allocation is permanent. Refresh only zero-state accounts so replays cannot reorder cap already committed to healthy accounts.
+    const replay = new Map([...pending].filter(([recipient]) => {
+        const account = accounts.get(recipient);
+        return (!account ||
+            (account.allocatedPrincipalAssets === 0n &&
+                account.lots.length === 0 &&
+                account.qualifiedEarnShares === 0n));
+    }));
+    const retained = options.accounts.filter((account) => !replay.has(account.recipient.toLowerCase()));
+    const remainingCap = options.totalPrincipalCapAssets -
+        retained.reduce((sum, account) => sum + account.allocatedPrincipalAssets, 0n);
+    const initialized = bootstrap({
+        eligible: [...replay.values()].map((entry) => ({
+            recipient: entry.recipient,
+            registrationOrder: entry.registrationOrder,
+        })),
+        events: options.events,
+        excluded: options.excluded,
+        perUserPrincipalCapAssets: options.perUserPrincipalCapAssets,
+        principalAllocationOrder: options.principalAllocationOrder,
+        totalPrincipalCapAssets: remainingCap,
+    });
+    return {
+        accounts: [
+            ...retained.map((account) => {
+                const entry = pending.get(account.recipient.toLowerCase());
+                return entry ? { ...account, eligibilityRegisteredAt: entry.registeredAt } : account;
+            }),
+            ...initialized.accounts.map((account) => {
+                const entry = pending.get(account.recipient.toLowerCase());
+                const previous = accounts.get(account.recipient.toLowerCase());
+                return {
+                    ...account,
+                    accrualRemainder: previous?.accrualRemainder ?? 0n,
+                    cumulativeEntitlement: previous?.cumulativeEntitlement ?? 0n,
+                    cumulativePaid: previous?.cumulativePaid ?? 0n,
+                    ...(previous?.deferral ? { deferral: previous.deferral } : {}),
+                    eligibilityRegisteredAt: entry.registeredAt,
+                    pendingRewardAssets: previous?.pendingRewardAssets ?? 0n,
+                };
+            }),
+        ].sort(compareAccounts),
+        reconciled: true,
+    };
+}
+/** Calculates time-weighted boost rewards for one interval. */
+export function calculate(options) {
+    if (options.endsAt <= options.startsAt)
+        throw new Error('reward interval is empty');
+    const accounts = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), clone(account)]));
+    const eligible = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), account.registrationOrder]));
+    const excluded = new Set(options.excluded.map((address) => address.toLowerCase()));
+    const weighted = new Map();
+    const accruedThrough = new Map();
+    let allocated = [...accounts.values()].reduce((sum, account) => sum + account.allocatedPrincipalAssets, 0n);
+    const events = [...options.events]
+        .filter((event) => event.timestamp >= options.startsAt && event.timestamp < options.endsAt)
+        .sort(compareEvents);
+    for (const event of events) {
+        for (const recipient of eventRecipients(event)) {
+            const account = accounts.get(recipient.toLowerCase());
+            if (account)
+                accumulateAccount(weighted, accruedThrough, account, excluded, options.startsAt, event.timestamp);
+        }
+        allocated = applyEvent(accounts, eligible, excluded, event, {
+            allocated,
+            perUserPrincipalCapAssets: options.perUserPrincipalCapAssets,
+            totalPrincipalCapAssets: options.totalPrincipalCapAssets,
+        });
+    }
+    for (const account of accounts.values())
+        accumulateAccount(weighted, accruedThrough, account, excluded, options.startsAt, options.endsAt);
+    const rewards = new Map();
+    const denominator = sharePriceScale * rateScale * secondsPerYear;
+    for (const account of accounts.values()) {
+        const shareSeconds = weighted.get(account.recipient.toLowerCase()) ?? 0n;
+        const numerator = shareSeconds * options.assetPerEarnShareWad * BigInt(options.annualRateBps) +
+            account.accrualRemainder;
+        const amount = numerator / denominator;
+        account.accrualRemainder = numerator % denominator;
+        account.pendingRewardAssets += amount;
+        if (amount > 0n)
+            rewards.set(account.recipient, amount);
+    }
+    return { accounts: [...accounts.values()].sort(compareAccounts), rewards };
+}
+/** Calculates one reward interval pagewise and checkpoints exact arithmetic state. */
+export async function calculatePages(options) {
+    if (options.endsAt <= options.startsAt)
+        throw new Error('reward interval is empty');
+    const accounts = new Map((options.checkpoint?.accounts.map(fromSnapshot) ?? options.accounts.map(clone)).map((account) => [account.recipient.toLowerCase(), account]));
+    const eligible = new Map(options.accounts.map((account) => [account.recipient.toLowerCase(), account.registrationOrder]));
+    const excluded = new Set(options.excluded.map((address) => address.toLowerCase()));
+    const accruedThrough = new Map(Object.entries(options.checkpoint?.accruedThrough ?? {}));
+    const weighted = new Map(Object.entries(options.checkpoint?.weightedEarnShareSeconds ?? {}).map(([recipient, value]) => [
+        recipient,
+        BigInt(value),
+    ]));
+    let allocated = [...accounts.values()].reduce((sum, account) => sum + account.allocatedPrincipalAssets, 0n);
+    for await (const page of options.pages) {
+        const events = [...page]
+            .filter((event) => event.timestamp >= options.startsAt && event.timestamp < options.endsAt)
+            .sort(compareEvents);
+        for (const event of events) {
+            for (const recipient of eventRecipients(event)) {
+                const account = accounts.get(recipient.toLowerCase());
+                if (account)
+                    accumulateAccount(weighted, accruedThrough, account, excluded, options.startsAt, event.timestamp);
+            }
+            allocated = applyEvent(accounts, eligible, excluded, event, {
+                allocated,
+                perUserPrincipalCapAssets: options.perUserPrincipalCapAssets,
+                totalPrincipalCapAssets: options.totalPrincipalCapAssets,
+            });
+        }
+        const cursor = page.at(-1)?.cursor;
+        if (cursor)
+            await options.checkpointState?.({
+                accounts: [...accounts.values()].sort(compareAccounts).map(snapshot),
+                accruedThrough: Object.fromEntries(accruedThrough),
+                weightedEarnShareSeconds: Object.fromEntries([...weighted].map(([recipient, value]) => [recipient, value.toString()])),
+            }, cursor);
+    }
+    for (const account of accounts.values())
+        accumulateAccount(weighted, accruedThrough, account, excluded, options.startsAt, options.endsAt);
+    const rewards = new Map();
+    const denominator = sharePriceScale * rateScale * secondsPerYear;
+    for (const account of accounts.values()) {
+        const shareSeconds = weighted.get(account.recipient.toLowerCase()) ?? 0n;
+        const numerator = shareSeconds * options.assetPerEarnShareWad * BigInt(options.annualRateBps) +
+            account.accrualRemainder;
+        const amount = numerator / denominator;
+        account.accrualRemainder = numerator % denominator;
+        account.pendingRewardAssets += amount;
+        if (amount > 0n)
+            rewards.set(account.recipient, amount);
+    }
+    return { accounts: [...accounts.values()].sort(compareAccounts), rewards };
+}
+/** Converts a database account into the arithmetic projection. */
+export function fromRecord(record) {
+    return {
+        accrualRemainder: BigInt(record.accrualRemainder),
+        allocatedPrincipalAssets: BigInt(record.allocatedPrincipalAssets),
+        cumulativeEntitlement: BigInt(record.cumulativeEntitlement),
+        cumulativePaid: BigInt(record.cumulativePaid),
+        ...(record.deferral ? { deferral: record.deferral } : {}),
+        ...(record.eligibilityRegisteredAt
+            ? { eligibilityRegisteredAt: record.eligibilityRegisteredAt }
+            : {}),
+        lots: [],
+        pendingRewardAssets: BigInt(record.pendingRewardAssets),
+        publicEarnShares: BigInt(record.publicEarnShares),
+        qualifiedEarnShares: BigInt(record.qualifiedEarnShares),
+        recipient: getAddress(record.recipient),
+        registrationOrder: BigInt(record.registrationOrder),
+    };
+}
+function account(accounts, eligible, excluded, address) {
+    const key = address.toLowerCase();
+    if (excluded.has(key))
+        return undefined;
+    const order = eligible.get(key);
+    if (order === undefined)
+        return undefined;
+    const existing = accounts.get(key);
+    if (existing)
+        return existing;
+    const created = {
+        accrualRemainder: 0n,
+        allocatedPrincipalAssets: 0n,
+        cumulativeEntitlement: 0n,
+        cumulativePaid: 0n,
+        lots: [],
+        pendingRewardAssets: 0n,
+        publicEarnShares: 0n,
+        qualifiedEarnShares: 0n,
+        recipient: getAddress(address),
+        registrationOrder: order,
+    };
+    accounts.set(key, created);
+    return created;
+}
+function accumulateAccount(weighted, accruedThrough, account, excluded, startsAt, through) {
+    const key = account.recipient.toLowerCase();
+    const previous = accruedThrough.get(key) ?? startsAt;
+    const seconds = through - previous;
+    if (seconds < 0)
+        throw new Error('reward events are not time ordered');
+    if (!excluded.has(key)) {
+        const balance = minimum(account.publicEarnShares, account.qualifiedEarnShares);
+        weighted.set(key, (weighted.get(key) ?? 0n) + balance * BigInt(seconds));
+    }
+    accruedThrough.set(key, through);
+}
+function eventRecipients(event) {
+    if (event.kind === 'deposit')
+        return [event.recipient];
+    if (event.from.toLowerCase() === event.to.toLowerCase())
+        return [event.from];
+    return [event.from, event.to];
+}
+function applyEvent(accounts, eligible, excluded, event, caps) {
+    if (event.kind === 'deposit') {
+        const recipient = account(accounts, eligible, excluded, event.recipient);
+        if (!recipient || event.assets === 0n || event.earnShares === 0n)
+            return caps.allocated;
+        const allocatedAssets = minimum(event.assets, maximum(caps.perUserPrincipalCapAssets - recipient.allocatedPrincipalAssets, 0n), maximum(caps.totalPrincipalCapAssets - caps.allocated, 0n));
+        if (allocatedAssets === 0n)
+            return caps.allocated;
+        const qualifiedShares = (event.earnShares * allocatedAssets) / event.assets;
+        if (qualifiedShares === 0n)
+            return caps.allocated;
+        recipient.allocatedPrincipalAssets += allocatedAssets;
+        recipient.qualifiedEarnShares += qualifiedShares;
+        return caps.allocated + allocatedAssets;
+    }
+    if (sameAddress(event.from, event.to))
+        return caps.allocated;
+    if (event.from.toLowerCase() !== zeroAddress) {
+        const sender = accounts.get(event.from.toLowerCase());
+        if (sender)
+            send(sender, event.amount);
+    }
+    if (event.to.toLowerCase() !== zeroAddress) {
+        const recipient = account(accounts, eligible, excluded, event.to);
+        if (recipient)
+            recipient.publicEarnShares += event.amount;
+    }
+    return caps.allocated;
+}
+function send(account, amount) {
+    account.publicEarnShares = maximum(account.publicEarnShares - amount, 0n);
+    account.qualifiedEarnShares = maximum(account.qualifiedEarnShares - amount, 0n);
+}
+function sendLots(account, amount) {
+    account.publicEarnShares = maximum(account.publicEarnShares - amount, 0n);
+    let remaining = amount;
+    for (const lot of account.lots) {
+        if (remaining === 0n)
+            break;
+        const shares = BigInt(lot.remainingEarnShares);
+        const consumed = minimum(shares, remaining);
+        lot.remainingEarnShares = (shares - consumed).toString();
+        account.qualifiedEarnShares -= consumed;
+        remaining -= consumed;
+    }
+}
+function sameAddress(left, right) {
+    return left.toLowerCase() === right.toLowerCase();
+}
+function clone(account) {
+    return { ...account, lots: account.lots.map((lot) => ({ ...lot, event: { ...lot.event } })) };
+}
+function compareAccounts(left, right) {
+    return left.registrationOrder < right.registrationOrder
+        ? -1
+        : left.registrationOrder > right.registrationOrder
+            ? 1
+            : left.recipient.toLowerCase().localeCompare(right.recipient.toLowerCase());
+}
+function compareEvents(left, right) {
+    return compareCursors(left.cursor, right.cursor);
+}
+function compareCursors(left, right) {
+    return (left.blockNumber - right.blockNumber ||
+        left.transactionIndex - right.transactionIndex ||
+        left.logIndex - right.logIndex);
+}
+function maximum(left, right) {
+    return left > right ? left : right;
+}
+function minimum(...values) {
+    return values.reduce((result, value) => (value < result ? value : result));
+}
+//# sourceMappingURL=Projection.js.map