@powerhousedao/contributor-billing 0.1.31 → 0.1.32

package/dist/editors/snapshot-report-editor/hooks/useSyncSnapshotAccount.js

@@ -0,0 +1,327 @@
+/**
+ * Hook for syncing snapshot accounts with account transactions documents
+ * Similar to useSyncWallet in expense-report
+ */
+import { useDocumentsInSelectedDrive, useSelectedDrive, dispatchActions, } from "@powerhousedao/reactor-browser";
+import { generateId } from "document-model/core";
+import { accountTransactionsService } from "../../accounts-editor/services/accountTransactionsService.js";
+import { actions as accountsActions } from "../../../document-models/accounts/index.js";
+import { actions as snapshotActions, balancesActions, transactionsActions, } from "../../../document-models/snapshot-report/index.js";
+import { calculateBalances } from "../utils/balanceCalculations.js";
+import { deriveTransactionsForAccount } from "../utils/deriveTransactions.js";
+import { calculateTransactionFlowInfo } from "../utils/flowTypeCalculations.js";
+export function useSyncSnapshotAccount() {
+    const documents = useDocumentsInSelectedDrive();
+    const [selectedDrive] = useSelectedDrive();
+    const syncAccount = async (snapshotAccount, accountEntry, accountsDocumentId, startDate, endDate, dispatch, allSnapshotAccounts = [], snapshotDocumentId) => {
+        if (!documents || !startDate || !endDate) {
+            return {
+                success: false,
+                message: "Missing required data (documents, startDate, or endDate)",
+            };
+        }
+        try {
+            // Handle non-Internal accounts differently - derive from Internal accounts
+            if (snapshotAccount.type !== "Internal") {
+                return await syncNonInternalAccount(snapshotAccount, startDate, endDate, dispatch, allSnapshotAccounts, snapshotDocumentId);
+            }
+            // For Internal accounts: sync from AccountTransactions document
+            // Step 1: Ensure account transactions document exists
+            let accountTransactionsDocId = snapshotAccount.accountTransactionsId;
+            if (!accountTransactionsDocId && accountEntry) {
+                // Create account transactions document
+                const driveId = selectedDrive?.header?.id;
+                if (!driveId) {
+                    return {
+                        success: false,
+                        message: "No drive selected",
+                    };
+                }
+                const result = await accountTransactionsService.createAccountTransactionsDocument(accountEntry, accountsDocumentId || "", driveId);
+                if (!result.success || !result.documentId) {
+                    return {
+                        success: false,
+                        message: result.message ||
+                            "Failed to create account transactions document",
+                    };
+                }
+                accountTransactionsDocId = result.documentId;
+            }
+            // Step 2: Get account transactions document
+            if (!accountTransactionsDocId) {
+                return {
+                    success: false,
+                    message: "No account transactions document available",
+                };
+            }
+            const txDoc = documents.find((doc) => doc.header.id === accountTransactionsDocId &&
+                doc.header.documentType === "powerhouse/account-transactions");
+            if (!txDoc?.state?.global?.transactions) {
+                return {
+                    success: false,
+                    message: "Account transactions document not found or has no transactions",
+                };
+            }
+            const allTransactions = txDoc.state.global.transactions;
+            // Step 3: Filter transactions by period
+            const start = new Date(startDate);
+            const end = new Date(endDate);
+            const periodTransactions = allTransactions.filter((tx) => {
+                if (!tx?.datetime)
+                    return false;
+                const txDate = new Date(tx.datetime);
+                if (isNaN(txDate.getTime()))
+                    return false;
+                return txDate >= start && txDate <= end;
+            });
+            // Step 4: Check if transactions have changed before updating
+            // Compare by transactionId to detect actual changes
+            const existingTransactionIds = new Set(snapshotAccount.transactions.map((tx) => tx.transactionId));
+            const newTransactionIds = new Set(periodTransactions.map((tx) => tx.id));
+            // Check if the sets are identical (no changes needed)
+            const hasChanges = existingTransactionIds.size !== newTransactionIds.size ||
+                [...existingTransactionIds].some((id) => !newTransactionIds.has(id)) ||
+                [...newTransactionIds].some((id) => !existingTransactionIds.has(id));
+            if (!hasChanges) {
+                return {
+                    success: true,
+                    message: "No changes detected - already in sync",
+                    transactionsAdded: snapshotAccount.transactions.length,
+                    documentId: accountTransactionsDocId,
+                };
+            }
+            // Step 5: Calculate balances BEFORE making any changes
+            // Map account transactions format to snapshot transaction format
+            const allTransactionsForBalance = allTransactions.map((tx) => {
+                // Extract token from transaction
+                const token = tx.details?.token ||
+                    (typeof tx.amount === "object" && tx.amount?.unit
+                        ? tx.amount.unit
+                        : typeof tx.amount === "string"
+                            ? tx.amount.split(" ")[1] || ""
+                            : "");
+                return {
+                    id: String(tx.id),
+                    transactionId: String(tx.id),
+                    counterParty: tx.counterParty || null,
+                    amount: tx.amount,
+                    datetime: tx.datetime,
+                    txHash: tx.details?.txHash || "",
+                    token: token,
+                    blockNumber: tx.details?.blockNumber ?? null,
+                    direction: tx.direction,
+                    flowType: null,
+                    counterPartyAccountId: null,
+                };
+            });
+            const balances = calculateBalances(allTransactionsForBalance, startDate, endDate, snapshotAccount.type);
+            // Build all actions into a single batch for efficiency
+            const allActions = [];
+            // 1. Remove existing transactions
+            snapshotAccount.transactions.forEach((tx) => {
+                allActions.push(transactionsActions.removeTransaction({ id: tx.id }));
+            });
+            // 2. Add new transactions
+            for (const tx of periodTransactions) {
+                const { flowType, counterPartyAccountId } = calculateTransactionFlowInfo(tx.direction, snapshotAccount.type, tx.counterParty, allSnapshotAccounts.length > 0
+                    ? allSnapshotAccounts
+                    : [snapshotAccount]);
+                allActions.push(transactionsActions.addTransaction({
+                    accountId: snapshotAccount.id,
+                    id: generateId(),
+                    transactionId: tx.id,
+                    counterParty: tx.counterParty || undefined,
+                    amount: tx.amount,
+                    datetime: tx.datetime,
+                    txHash: tx.details?.txHash || "",
+                    token: tx.details?.token || "",
+                    blockNumber: tx.details?.blockNumber || undefined,
+                    direction: tx.direction,
+                    flowType: flowType,
+                    counterPartyAccountId: counterPartyAccountId || undefined,
+                }));
+            }
+            // 3. Remove existing starting balances
+            snapshotAccount.startingBalances.forEach((b) => {
+                allActions.push(balancesActions.removeStartingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: b.id,
+                }));
+            });
+            // 4. Add new starting balances
+            balances.forEach((balance) => {
+                allActions.push(balancesActions.setStartingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: generateId(),
+                    token: balance.token,
+                    amount: balance.opening,
+                }));
+            });
+            // 5. Remove existing ending balances
+            snapshotAccount.endingBalances.forEach((b) => {
+                allActions.push(balancesActions.removeEndingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: b.id,
+                }));
+            });
+            // 6. Add new ending balances
+            balances.forEach((balance) => {
+                allActions.push(balancesActions.setEndingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: generateId(),
+                    token: balance.token,
+                    amount: balance.closing,
+                }));
+            });
+            // Dispatch all actions in a single batch if we have a document ID
+            if (snapshotDocumentId && allActions.length > 0) {
+                await dispatchActions(allActions, snapshotDocumentId);
+            }
+            else {
+                // Fallback to individual dispatches if no document ID
+                allActions.forEach((action) => dispatch(action));
+            }
+            return {
+                success: true,
+                message: `Synced ${periodTransactions.length} transactions and updated balances`,
+                transactionsAdded: periodTransactions.length,
+                documentId: accountTransactionsDocId,
+            };
+        }
+        catch (error) {
+            console.error("[useSyncSnapshotAccount] Error syncing account:", error);
+            return {
+                success: false,
+                message: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+    };
+    /**
+     * Sync a non-Internal account by deriving transactions from Internal accounts
+     */
+    const syncNonInternalAccount = async (snapshotAccount, startDate, endDate, dispatch, allSnapshotAccounts, snapshotDocumentId) => {
+        try {
+            // Get Internal accounts with their transactions
+            const internalAccounts = allSnapshotAccounts.filter((acc) => acc.type === "Internal");
+            if (internalAccounts.length === 0) {
+                return {
+                    success: false,
+                    message: "No Internal accounts found. Import Internal accounts first to derive transactions.",
+                };
+            }
+            // Derive transactions from Internal accounts
+            const derivedTransactions = deriveTransactionsForAccount(snapshotAccount, internalAccounts);
+            // Filter to period for snapshot
+            const start = new Date(startDate);
+            const end = new Date(endDate);
+            const periodTransactions = derivedTransactions.filter((tx) => {
+                const txDate = new Date(tx.datetime);
+                return txDate >= start && txDate <= end;
+            });
+            // Check if transactions have changed before updating
+            const existingTransactionIds = new Set(snapshotAccount.transactions.map((tx) => tx.transactionId));
+            const newTransactionIds = new Set(periodTransactions.map((tx) => tx.transactionId));
+            const hasChanges = existingTransactionIds.size !== newTransactionIds.size ||
+                [...existingTransactionIds].some((id) => !newTransactionIds.has(id)) ||
+                [...newTransactionIds].some((id) => !existingTransactionIds.has(id));
+            if (!hasChanges) {
+                return {
+                    success: true,
+                    message: "No changes detected - already in sync",
+                    transactionsAdded: snapshotAccount.transactions.length,
+                };
+            }
+            // Calculate balances using ALL derived transactions (not just period)
+            const allTransactionsForBalance = derivedTransactions.map((tx) => ({
+                id: tx.id,
+                transactionId: tx.transactionId,
+                counterParty: tx.counterParty,
+                amount: tx.amount,
+                datetime: tx.datetime,
+                txHash: tx.txHash,
+                token: tx.token,
+                blockNumber: tx.blockNumber,
+                direction: tx.direction,
+                flowType: tx.flowType,
+                counterPartyAccountId: tx.counterPartyAccountId,
+            }));
+            const balances = calculateBalances(allTransactionsForBalance, startDate, endDate, snapshotAccount.type);
+            // Build all actions into a single batch for efficiency
+            const allActions = [];
+            // 1. Remove existing transactions
+            snapshotAccount.transactions.forEach((tx) => {
+                allActions.push(transactionsActions.removeTransaction({ id: tx.id }));
+            });
+            // 2. Add derived transactions
+            for (const tx of periodTransactions) {
+                allActions.push(transactionsActions.addTransaction({
+                    accountId: snapshotAccount.id,
+                    id: tx.id,
+                    transactionId: tx.transactionId,
+                    counterParty: tx.counterParty,
+                    amount: tx.amount,
+                    datetime: tx.datetime,
+                    txHash: tx.txHash,
+                    token: tx.token,
+                    blockNumber: tx.blockNumber ?? undefined,
+                    direction: tx.direction,
+                    flowType: tx.flowType,
+                    counterPartyAccountId: tx.counterPartyAccountId,
+                }));
+            }
+            // 3. Remove existing starting balances
+            snapshotAccount.startingBalances.forEach((b) => {
+                allActions.push(balancesActions.removeStartingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: b.id,
+                }));
+            });
+            // 4. Add new starting balances
+            balances.forEach((balance) => {
+                allActions.push(balancesActions.setStartingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: generateId(),
+                    token: balance.token,
+                    amount: balance.opening,
+                }));
+            });
+            // 5. Remove existing ending balances
+            snapshotAccount.endingBalances.forEach((b) => {
+                allActions.push(balancesActions.removeEndingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: b.id,
+                }));
+            });
+            // 6. Add new ending balances
+            balances.forEach((balance) => {
+                allActions.push(balancesActions.setEndingBalance({
+                    accountId: snapshotAccount.id,
+                    balanceId: generateId(),
+                    token: balance.token,
+                    amount: balance.closing,
+                }));
+            });
+            // Dispatch all actions in a single batch if we have a document ID
+            if (snapshotDocumentId && allActions.length > 0) {
+                await dispatchActions(allActions, snapshotDocumentId);
+            }
+            else {
+                // Fallback to individual dispatches if no document ID
+                allActions.forEach((action) => dispatch(action));
+            }
+            return {
+                success: true,
+                message: `Derived ${periodTransactions.length} transactions from Internal accounts`,
+                transactionsAdded: periodTransactions.length,
+            };
+        }
+        catch (error) {
+            console.error("[useSyncSnapshotAccount] Error syncing non-Internal account:", error);
+            return {
+                success: false,
+                message: `Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+    };
+    return { syncAccount };
+}

package/dist/editors/snapshot-report-editor/module.d.ts

@@ -0,0 +1,3 @@
+import type { EditorModule } from "document-model";
+export declare const SnapshotReportEditor: EditorModule;
+//# sourceMappingURL=module.d.ts.map

package/dist/editors/snapshot-report-editor/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../editors/snapshot-report-editor/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAGnD,eAAO,MAAM,oBAAoB,EAAE,YAOlC,CAAC"}

package/dist/editors/snapshot-report-editor/module.js

@@ -0,0 +1,9 @@
+import { lazy } from "react";
+export const SnapshotReportEditor = {
+    Component: lazy(() => import("./editor.js")),
+    documentTypes: ["powerhouse/snapshot-report"],
+    config: {
+        id: "powerhouse-snapshot-report-editor",
+        name: "Snapshot Report",
+    },
+};

package/dist/editors/snapshot-report-editor/utils/balanceCalculations.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility functions for calculating opening and closing balances
+ * from transactions in snapshot reports
+ */
+import type { SnapshotTransaction } from "../../../document-models/snapshot-report/gen/types.js";
+import type { Scalars, AccountType } from "../../../document-models/snapshot-report/gen/schema/types.js";
+export type Amount_Currency = Scalars["Amount_Currency"]["output"];
+export interface TokenBalance {
+    token: string;
+    opening: Amount_Currency;
+    closing: Amount_Currency;
+}
+/**
+ * Calculate opening and closing balances for all tokens from transactions
+ * @param transactions - All transactions for the account
+ * @param startDate - Period start date (ISO string)
+ * @param endDate - Period end date (ISO string)
+ * @param accountType - Optional account type for type-specific balance logic
+ * @returns Map of token to balance information
+ */
+export declare function calculateBalances(transactions: SnapshotTransaction[], startDate: string, endDate: string, accountType?: AccountType): Map<string, TokenBalance>;
+/**
+ * Format balance amount for display
+ */
+export declare function formatBalance(amount: Amount_Currency): string;
+//# sourceMappingURL=balanceCalculations.d.ts.map

package/dist/editors/snapshot-report-editor/utils/balanceCalculations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"balanceCalculations.d.ts","sourceRoot":"","sources":["../../../../editors/snapshot-report-editor/utils/balanceCalculations.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uDAAuD,CAAC;AACjG,OAAO,KAAK,EACV,OAAO,EACP,WAAW,EACZ,MAAM,8DAA8D,CAAC;AAEtE,MAAM,MAAM,eAAe,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC,QAAQ,CAAC,CAAC;AAEnE,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,eAAe,CAAC;IACzB,OAAO,EAAE,eAAe,CAAC;CAC1B;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,YAAY,EAAE,mBAAmB,EAAE,EACnC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,WAAW,CAAC,EAAE,WAAW,GACxB,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAiE3B;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAO7D"}

package/dist/editors/snapshot-report-editor/utils/balanceCalculations.js

@@ -0,0 +1,103 @@
+/**
+ * Utility functions for calculating opening and closing balances
+ * from transactions in snapshot reports
+ */
+/**
+ * Calculate the effect of a transaction on balance based on account type
+ *
+ * - Internal accounts: Standard balance (INFLOW +, OUTFLOW -)
+ * - Source accounts: Track "cumulative provided" (OUTFLOW = funds sent to team = positive)
+ * - Destination accounts: Track "cumulative received" (INFLOW = funds received from team = positive)
+ * - External accounts: Net flows with team (standard balance)
+ */
+function getTransactionEffect(direction, amountValue, accountType) {
+    // For Source accounts: OUTFLOW means funds provided (positive)
+    if (accountType === "Source") {
+        return direction === "OUTFLOW" ? amountValue : -amountValue;
+    }
+    // For Destination accounts: INFLOW means funds received (positive)
+    if (accountType === "Destination") {
+        return direction === "INFLOW" ? amountValue : -amountValue;
+    }
+    // For Internal and External accounts: Standard balance
+    // INFLOW = positive, OUTFLOW = negative
+    return direction === "INFLOW" ? amountValue : -amountValue;
+}
+/**
+ * Calculate opening and closing balances for all tokens from transactions
+ * @param transactions - All transactions for the account
+ * @param startDate - Period start date (ISO string)
+ * @param endDate - Period end date (ISO string)
+ * @param accountType - Optional account type for type-specific balance logic
+ * @returns Map of token to balance information
+ */
+export function calculateBalances(transactions, startDate, endDate, accountType) {
+    const balances = new Map();
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    // Process all transactions
+    transactions.forEach((tx) => {
+        const txDate = new Date(tx.datetime);
+        const token = tx.token;
+        // Initialize balance for this token if not exists
+        if (!balances.has(token)) {
+            balances.set(token, {
+                token,
+                opening: { value: "0", unit: token },
+                closing: { value: "0", unit: token },
+            });
+        }
+        const balance = balances.get(token);
+        let amountStr;
+        const txAmount = tx.amount;
+        if (typeof txAmount === "object" && txAmount?.value !== undefined) {
+            amountStr = txAmount.value;
+        }
+        else if (typeof txAmount === "string") {
+            amountStr = txAmount.split(" ")[0] || "0";
+        }
+        else {
+            amountStr = "0";
+        }
+        const amountValue = parseFloat(amountStr);
+        const effect = getTransactionEffect(tx.direction, amountValue, accountType);
+        // Calculate opening balance (transactions before period start)
+        if (txDate < start) {
+            const currentOpening = parseFloat(balance.opening.value || "0");
+            balance.opening.value = (currentOpening + effect).toString();
+        }
+        // Calculate period change (transactions during period)
+        if (txDate >= start && txDate <= end) {
+            const currentClosing = parseFloat(balance.closing.value || "0");
+            balance.closing.value = (currentClosing + effect).toString();
+        }
+    });
+    // Finalize closing balances (opening + period changes)
+    // Fix floating-point precision errors (e.g., -0.0000001 → 0)
+    const fixPrecision = (value) => {
+        // Only fix values very close to zero (floating-point errors)
+        // Allow real negative balances for non-Internal accounts
+        if (Math.abs(value) < 1e-10)
+            return 0;
+        return value;
+    };
+    balances.forEach((balance) => {
+        const openingValue = parseFloat(balance.opening.value || "0");
+        const periodChange = parseFloat(balance.closing.value || "0");
+        const closingValue = openingValue + periodChange;
+        balance.opening.value = fixPrecision(openingValue).toString();
+        balance.closing.value = fixPrecision(closingValue).toString();
+    });
+    return balances;
+}
+/**
+ * Format balance amount for display
+ */
+export function formatBalance(amount) {
+    if (typeof amount === "object" && amount?.value !== undefined) {
+        const value = parseFloat(amount.value);
+        return `${value.toFixed(6)} ${amount.unit || ""}`.trim();
+    }
+    // Amount_Currency should always be an object with value/unit
+    return "0";
+}

package/dist/editors/snapshot-report-editor/utils/deriveTransactions.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Utility for deriving transactions for non-Internal accounts
+ * from Internal account transactions where they appear as counter-parties.
+ *
+ * This allows Source/Destination/External accounts to show their interactions
+ * with Internal accounts without requiring their own AccountTransactions documents.
+ */
+import type { SnapshotAccount, TransactionFlowType } from "../../../document-models/snapshot-report/gen/schema/types.js";
+/**
+ * Derived transaction ready to be added to a snapshot account
+ */
+export interface DerivedTransactionInput {
+    id: string;
+    transactionId: string;
+    counterParty: string;
+    counterPartyAccountId: string;
+    amount: {
+        value: string;
+        unit: string;
+    };
+    datetime: string;
+    txHash: string;
+    token: string;
+    blockNumber: number | null;
+    direction: "INFLOW" | "OUTFLOW";
+    flowType: TransactionFlowType;
+}
+/**
+ * Derive transactions for a non-Internal account by scanning Internal account transactions
+ *
+ * @param account - The Source/Destination/External account to derive transactions for
+ * @param internalAccounts - All Internal accounts with their transactions
+ * @returns Array of derived transactions from the account's perspective
+ */
+export declare function deriveTransactionsForAccount(account: SnapshotAccount, internalAccounts: SnapshotAccount[]): DerivedTransactionInput[];
+/**
+ * Derive transactions for all non-Internal accounts in the snapshot
+ *
+ * @param snapshotAccounts - All accounts in the snapshot
+ * @returns Map of account ID to derived transactions
+ */
+export declare function deriveTransactionsForAllNonInternalAccounts(snapshotAccounts: SnapshotAccount[]): Map<string, DerivedTransactionInput[]>;
+/**
+ * Check if an account should have derived transactions (non-Internal types)
+ */
+export declare function shouldDeriveTransactions(accountType: string): boolean;
+//# sourceMappingURL=deriveTransactions.d.ts.map

package/dist/editors/snapshot-report-editor/utils/deriveTransactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveTransactions.d.ts","sourceRoot":"","sources":["../../../../editors/snapshot-report-editor/utils/deriveTransactions.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACpB,MAAM,8DAA8D,CAAC;AAGtE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,EAAE,EAAE,MAAM,CAAC;IACX,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;IAChC,QAAQ,EAAE,mBAAmB,CAAC;CAC/B;AAUD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,eAAe,EACxB,gBAAgB,EAAE,eAAe,EAAE,GAClC,uBAAuB,EAAE,CAuD3B;AAED;;;;;GAKG;AACH,wBAAgB,2CAA2C,CACzD,gBAAgB,EAAE,eAAe,EAAE,GAClC,GAAG,CAAC,MAAM,EAAE,uBAAuB,EAAE,CAAC,CAgBxC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAErE"}

package/dist/editors/snapshot-report-editor/utils/deriveTransactions.js

@@ -0,0 +1,89 @@
+/**
+ * Utility for deriving transactions for non-Internal accounts
+ * from Internal account transactions where they appear as counter-parties.
+ *
+ * This allows Source/Destination/External accounts to show their interactions
+ * with Internal accounts without requiring their own AccountTransactions documents.
+ */
+import { generateId } from "document-model/core";
+import { calculateFlowType } from "./flowTypeCalculations.js";
+/**
+ * Invert the direction of a transaction
+ * When deriving from Internal account's perspective to the counter-party's perspective
+ */
+function invertDirection(direction) {
+    return direction === "INFLOW" ? "OUTFLOW" : "INFLOW";
+}
+/**
+ * Derive transactions for a non-Internal account by scanning Internal account transactions
+ *
+ * @param account - The Source/Destination/External account to derive transactions for
+ * @param internalAccounts - All Internal accounts with their transactions
+ * @returns Array of derived transactions from the account's perspective
+ */
+export function deriveTransactionsForAccount(account, internalAccounts) {
+    const derivedTransactions = [];
+    const accountAddressLower = account.accountAddress.toLowerCase();
+    // Scan all Internal accounts
+    for (const internalAccount of internalAccounts) {
+        // Find transactions where the counter-party is our target account
+        for (const tx of internalAccount.transactions) {
+            if (tx.counterParty?.toLowerCase() === accountAddressLower) {
+                // Derive the transaction from the non-Internal account's perspective
+                const invertedDirection = invertDirection(tx.direction);
+                // Calculate flow type from the derived account's perspective
+                const flowType = calculateFlowType(invertedDirection, account.type, internalAccount.type);
+                // Parse amount
+                const txAmount = tx.amount;
+                let amount;
+                if (typeof txAmount === "object" && txAmount.value !== undefined) {
+                    amount = { value: txAmount.value, unit: txAmount.unit || tx.token };
+                }
+                else if (typeof txAmount === "string") {
+                    amount = { value: txAmount.split(" ")[0] || "0", unit: tx.token };
+                }
+                else {
+                    amount = { value: "0", unit: tx.token };
+                }
+                derivedTransactions.push({
+                    id: generateId(),
+                    transactionId: tx.transactionId, // Reference to original transaction
+                    counterParty: internalAccount.accountAddress, // The Internal account is now the counter-party
+                    counterPartyAccountId: internalAccount.id,
+                    amount,
+                    datetime: tx.datetime,
+                    txHash: tx.txHash,
+                    token: tx.token,
+                    blockNumber: tx.blockNumber ?? null,
+                    direction: invertedDirection,
+                    flowType,
+                });
+            }
+        }
+    }
+    // Sort by datetime
+    derivedTransactions.sort((a, b) => new Date(a.datetime).getTime() - new Date(b.datetime).getTime());
+    return derivedTransactions;
+}
+/**
+ * Derive transactions for all non-Internal accounts in the snapshot
+ *
+ * @param snapshotAccounts - All accounts in the snapshot
+ * @returns Map of account ID to derived transactions
+ */
+export function deriveTransactionsForAllNonInternalAccounts(snapshotAccounts) {
+    const internalAccounts = snapshotAccounts.filter((acc) => acc.type === "Internal");
+    const nonInternalAccounts = snapshotAccounts.filter((acc) => acc.type !== "Internal");
+    const derivedByAccount = new Map();
+    for (const account of nonInternalAccounts) {
+        const derived = deriveTransactionsForAccount(account, internalAccounts);
+        derivedByAccount.set(account.id, derived);
+    }
+    return derivedByAccount;
+}
+/**
+ * Check if an account should have derived transactions (non-Internal types)
+ */
+export function shouldDeriveTransactions(accountType) {
+    return accountType !== "Internal";
+}

package/dist/editors/snapshot-report-editor/utils/flowTypeCalculations.d.ts

@@ -0,0 +1,29 @@
+import type { SnapshotAccount, TransactionFlowType } from "../../../document-models/snapshot-report/gen/schema/types.js";
+/**
+ * Calculate the flow type for a transaction based on account types
+ * @param direction - Transaction direction (INFLOW or OUTFLOW)
+ * @param accountType - Type of the account the transaction belongs to
+ * @param counterPartyType - Type of the counter-party account (if found)
+ * @returns The calculated flow type
+ */
+export declare function calculateFlowType(direction: string, accountType: string, counterPartyType: string | null): TransactionFlowType;
+/**
+ * Find a counter-party account by address in the snapshot accounts
+ * @param counterPartyAddress - The ethereum address of the counter-party
+ * @param snapshotAccounts - Array of snapshot accounts to search
+ * @returns The matching account or undefined
+ */
+export declare function findCounterPartyAccount(counterPartyAddress: string | null | undefined, snapshotAccounts: SnapshotAccount[]): SnapshotAccount | undefined;
+/**
+ * Calculate flow type and counter-party account ID for a transaction
+ * @param direction - Transaction direction
+ * @param accountType - Type of the account
+ * @param counterPartyAddress - Counter-party ethereum address
+ * @param snapshotAccounts - All snapshot accounts for lookup
+ * @returns Object with flowType and counterPartyAccountId
+ */
+export declare function calculateTransactionFlowInfo(direction: string, accountType: string, counterPartyAddress: string | null | undefined, snapshotAccounts: SnapshotAccount[]): {
+    flowType: TransactionFlowType;
+    counterPartyAccountId: string | null;
+};
+//# sourceMappingURL=flowTypeCalculations.d.ts.map

package/dist/editors/snapshot-report-editor/utils/flowTypeCalculations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowTypeCalculations.d.ts","sourceRoot":"","sources":["../../../../editors/snapshot-report-editor/utils/flowTypeCalculations.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,eAAe,EACf,mBAAmB,EACpB,MAAM,8DAA8D,CAAC;AAEtE;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAC9B,mBAAmB,CAyBrB;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9C,gBAAgB,EAAE,eAAe,EAAE,GAClC,eAAe,GAAG,SAAS,CAS7B;AAED;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,mBAAmB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC9C,gBAAgB,EAAE,eAAe,EAAE,GAClC;IACD,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;CACtC,CAgBA"}