@powerhousedao/contributor-billing 0.1.53 → 1.0.0-dev.10

package/dist/subgraphs/budget-statements/resolvers.js

@@ -1,38 +1,47 @@
 import {} from "@powerhousedao/reactor-api";
+// Helper to extract YYYY-MM-DD from an ISO date string without Date object
+// to avoid timezone-dependent parsing
+export const extractIsoDate = (dateStr) => {
+    const match = dateStr.match(/^(\d{4}-\d{2}-\d{2})/);
+    return match ? match[1] : null;
+};
 // Helper to create a period key from start and end dates
-const getPeriodKey = (periodStart, periodEnd) => {
+export const getPeriodKey = (periodStart, periodEnd) => {
     if (!periodStart || !periodEnd)
         return null;
-    // Normalize dates to YYYY-MM-DD format for consistent matching
-    const startDate = new Date(periodStart);
-    const endDate = new Date(periodEnd);
-    if (isNaN(startDate.getTime()) || isNaN(endDate.getTime()))
+    const start = extractIsoDate(periodStart);
+    const end = extractIsoDate(periodEnd);
+    if (!start || !end)
         return null;
-    const formatDate = (d) => d.toISOString().split("T")[0];
-    return `${formatDate(startDate)}_${formatDate(endDate)}`;
+    return `${start}_${end}`;
 };
-// Helper to extract month key from date (format: "JAN2026")
-const getMonthKey = (dateStr) => {
+const MONTHS = [
+    "JAN",
+    "FEB",
+    "MAR",
+    "APR",
+    "MAY",
+    "JUN",
+    "JUL",
+    "AUG",
+    "SEP",
+    "OCT",
+    "NOV",
+    "DEC",
+];
+// Helper to extract month key from an ISO date string (format: "SEP2025")
+// Parses directly from the string to avoid timezone issues
+export const getMonthKey = (dateStr) => {
     if (!dateStr)
         return null;
-    const date = new Date(dateStr);
-    if (isNaN(date.getTime()))
+    const match = dateStr.match(/^(\d{4})-(\d{2})/);
+    if (!match)
+        return null;
+    const year = match[1];
+    const monthIndex = parseInt(match[2], 10) - 1;
+    if (monthIndex < 0 || monthIndex > 11)
         return null;
-    const months = [
-        "JAN",
-        "FEB",
-        "MAR",
-        "APR",
-        "MAY",
-        "JUN",
-        "JUL",
-        "AUG",
-        "SEP",
-        "OCT",
-        "NOV",
-        "DEC",
-    ];
-    return `${months[date.getMonth()]}${date.getFullYear()}`;
+    return `${MONTHS[monthIndex]}${year}`;
 };
 // Helper to sort budget statements by month (most recent first)
 const sortByMonth = (a, b) => {
@@ -126,15 +135,24 @@ export const getResolvers = (subgraph) => {
                 const drivesToScan = drives;
                 for (const driveId of drivesToScan) {
                     const docsIds = await reactor.getDocuments(driveId);
-                    const docs = await Promise.all(docsIds.map(async (docId) => reactor.getDocument(docId)));
+                    const docs = await Promise.all(docsIds.map(async (docId) => {
+                        try {
+                            return await reactor.getDocument(docId);
+                        }
+                        catch {
+                            return null;
+                        }
+                    }));
                     for (const doc of docs) {
+                        if (!doc)
+                            continue;
                         const docType = doc.header.documentType;
                         if (docType === "powerhouse/snapshot-report") {
                             const snapshotDoc = doc;
                             const ownerId = snapshotDoc.state.global.ownerIds?.[0] ?? null;
-                            // Apply filters: teamId takes precedence, then networkSlug (via allowedBuilderPhids)
-                            if (teamId && ownerId !== teamId)
-                                continue;
+                            // Don't filter snapshot reports by teamId here — snapshots are often
+                            // owned by the operational hub, not individual teams. The opHub sharing
+                            // mechanism (Step 4) will associate them with the correct teams later.
                             if (allowedBuilderPhids &&
                                 ownerId &&
                                 !allowedBuilderPhids.has(ownerId))
@@ -162,9 +180,50 @@ export const getResolvers = (subgraph) => {
                         }
                     }
                 }
-                // Step 2: Group reports by ownerId AND period
+                // Step 2: Resolve builder profiles and build opHub lookup
+                // We need this before grouping so snapshot reports can be shared across op hub members
+                const resolvedProfiles = new Map();
+                const builderToOpHub = new Map();
+                const resolveProfile = async (phid) => {
+                    if (resolvedProfiles.has(phid))
+                        return resolvedProfiles.get(phid);
+                    let doc = builderProfileDocs.get(phid) || null;
+                    if (!doc) {
+                        try {
+                            doc = await reactor.getDocument(phid);
+                        }
+                        catch {
+                            // Profile may not exist
+                        }
+                    }
+                    const state = doc
+                        ? (doc.state
+                            ?.global ?? null)
+                        : null;
+                    resolvedProfiles.set(phid, state);
+                    if (state?.operationalHubMember?.phid) {
+                        builderToOpHub.set(phid, state.operationalHubMember.phid);
+                    }
+                    return state;
+                };
+                // Pre-resolve all builder profiles we'll need
+                const allOwnerIds = new Set();
+                for (const doc of snapshotReportDocs) {
+                    const id = doc.state.global.ownerIds?.[0];
+                    if (id)
+                        allOwnerIds.add(id);
+                }
+                for (const doc of expenseReportDocs) {
+                    const id = doc.state.global.ownerId;
+                    if (id)
+                        allOwnerIds.add(id);
+                }
+                await Promise.all(Array.from(allOwnerIds).map((id) => resolveProfile(id)));
+                // Step 3: Group reports by ownerId AND period
                 // Key format: "ownerId_periodStart_periodEnd"
                 const budgetStatementsByOwnerAndPeriod = new Map();
+                // Index snapshot reports by opHub + period so they can be shared
+                const snapshotByOpHub = new Map();
                 // Group snapshot reports
                 for (const snapshotDoc of snapshotReportDocs) {
                     const state = snapshotDoc.state.global;
@@ -185,6 +244,11 @@ export const getResolvers = (subgraph) => {
                     }
                     budgetStatementsByOwnerAndPeriod.get(key).snapshotReport =
                         snapshotDoc;
+                    // Also index by opHub + period for sharing across subteams
+                    const opHubPhid = builderToOpHub.get(ownerId);
+                    if (opHubPhid) {
+                        snapshotByOpHub.set(`${opHubPhid}_${periodKey}`, snapshotDoc);
+                    }
                 }
                 // Group expense reports and match with snapshot reports
                 for (const expenseDoc of expenseReportDocs) {
@@ -206,25 +270,22 @@ export const getResolvers = (subgraph) => {
                     }
                     budgetStatementsByOwnerAndPeriod.get(key).expenseReport = expenseDoc;
                 }
-                // Step 3: Build the budget statements
+                // Step 4: Fill in missing snapshot reports from op hub siblings
+                for (const entry of budgetStatementsByOwnerAndPeriod.values()) {
+                    if (entry.snapshotReport)
+                        continue; // already has a direct match
+                    const opHubPhid = builderToOpHub.get(entry.ownerId);
+                    if (!opHubPhid)
+                        continue;
+                    const opHubSnapshot = snapshotByOpHub.get(`${opHubPhid}_${entry.periodKey}`);
+                    if (opHubSnapshot) {
+                        entry.snapshotReport = opHubSnapshot;
+                    }
+                }
+                // Step 5: Build the budget statements
                 const budgetStatements = [];
                 for (const [key, { ownerId, periodKey, snapshotReport, expenseReport },] of budgetStatementsByOwnerAndPeriod.entries()) {
-                    // Get the builder profile for this owner
-                    let builderProfileDoc = builderProfileDocs.get(ownerId) || null;
-                    // Try to fetch directly if not found
-                    if (!builderProfileDoc) {
-                        try {
-                            builderProfileDoc =
-                                await reactor.getDocument(ownerId);
-                        }
-                        catch {
-                            // Ignore errors - profile may not exist
-                        }
-                    }
-                    // Build owner object
-                    const ownerState = builderProfileDoc
-                        ? (builderProfileDoc.state?.global ?? null)
-                        : null;
+                    const ownerState = resolvedProfiles.get(ownerId) ?? null;
                     const owner = {
                         id: ownerId,
                         name: ownerState?.name || "Unknown",
@@ -238,7 +299,7 @@ export const getResolvers = (subgraph) => {
                     const month = getMonthKey(periodStartDate) || periodKey;
                     // Build snapshot report data
                     const snapshotReportData = snapshotReport
-                        ? buildSnapshotReportData(snapshotReport, accountTransactionsDocs)
+                        ? buildSnapshotReportData(snapshotReport)
                         : {
                             startDate: "",
                             endDate: "",
@@ -257,19 +318,57 @@ export const getResolvers = (subgraph) => {
                     const status = expenseReport?.state.global.status || "DRAFT";
                     // Get lastModifiedAtUtcIso from the expense report document header
                     const lastModifiedAtUtcIso = expenseReport?.header.lastModifiedAtUtcIso || "";
+                    // Get operational hub member from builder profile
+                    const opHubMember = ownerState?.operationalHubMember ?? null;
+                    const operationalHubMember = opHubMember?.phid || opHubMember?.name
+                        ? {
+                            phid: opHubMember.phid || null,
+                            name: opHubMember.name || null,
+                        }
+                        : null;
                     budgetStatements.push({
                         id: key,
                         owner,
+                        operationalHubMember,
                         month,
                         status,
                         lastModifiedAtUtcIso,
+                        reportedActuals: computeReportedActuals(expenseReportData),
+                        netExpenseTxns: computeNetExpenseTxns(snapshotReportData),
                         snapshotReport: snapshotReportData,
                         expenseReport: expenseReportData,
                     });
                 }
+                // Aggregate reportedActuals by operational hub + month
+                // All builders in the same op hub for the same month share the same total
+                const opHubActuals = new Map();
+                for (const stmt of budgetStatements) {
+                    const opHubPhid = stmt.operationalHubMember?.phid;
+                    if (!opHubPhid)
+                        continue;
+                    const groupKey = `${opHubPhid}_${stmt.month}`;
+                    const current = opHubActuals.get(groupKey) || 0;
+                    opHubActuals.set(groupKey, current + (parseFloat(stmt.reportedActuals.value) || 0));
+                }
+                for (const stmt of budgetStatements) {
+                    const opHubPhid = stmt.operationalHubMember?.phid;
+                    if (!opHubPhid)
+                        continue;
+                    const groupKey = `${opHubPhid}_${stmt.month}`;
+                    const total = opHubActuals.get(groupKey);
+                    if (total !== undefined) {
+                        stmt.reportedActuals = { unit: "USDS", value: String(total) };
+                    }
+                }
+                // When filtering by teamId, remove entries for other owners that were
+                // only collected because we don't filter snapshot reports by teamId
+                // (snapshots are often owned by the opHub, not individual teams).
+                const filteredStatements = teamId
+                    ? budgetStatements.filter((stmt) => stmt.owner.id === teamId)
+                    : budgetStatements;
                 // Sort by month (most recent first)
-                budgetStatements.sort(sortByMonth);
-                return budgetStatements;
+                filteredStatements.sort(sortByMonth);
+                return filteredStatements;
             },
         },
     };
@@ -277,7 +376,7 @@ export const getResolvers = (subgraph) => {
 /**
  * Build snapshot report data from a SnapshotReportDocument
  */
-function buildSnapshotReportData(doc, accountTransactionsDocs) {
+function buildSnapshotReportData(doc) {
     const state = doc.state.global;
     return {
         startDate: state.reportPeriodStart || state.startDate || "",
@@ -304,7 +403,7 @@ function buildSnapshotReportData(doc, accountTransactionsDocs) {
                 datetime: tx.datetime,
                 txHash: tx.txHash,
                 counterParty: tx.counterParty || "",
-                counterPartyName: getCounterPartyName(tx.counterPartyAccountId, accountTransactionsDocs),
+                counterPartyName: getCounterPartyName(tx.counterParty, state.snapshotAccounts),
                 amount: {
                     value: tx.amount,
                     unit: tx.token,
@@ -390,17 +489,48 @@ function buildExpenseReportData(doc) {
     };
 }
 /**
- * Get counter party name from account-transactions document
+ * Get counter party name by matching the counter party address
+ * against snapshot account addresses.
  */
-function getCounterPartyName(counterPartyAccountId, accountTransactionsDocs) {
-    if (!counterPartyAccountId)
+function getCounterPartyName(counterPartyAddress, snapshotAccounts) {
+    if (!counterPartyAddress)
         return "";
-    // Search through all account-transactions docs to find the account name
-    for (const txDoc of accountTransactionsDocs.values()) {
-        const account = txDoc.state.global.account;
-        if (account && account.id === counterPartyAccountId) {
-            return account.name || "";
+    const account = snapshotAccounts.find((acc) => acc.accountAddress.toLowerCase() === counterPartyAddress.toLowerCase());
+    return account?.accountName || "";
+}
+/**
+ * Sum of all line item actuals from expense report wallets
+ */
+export function computeReportedActuals(expenseReportData) {
+    let total = 0;
+    for (const wallet of expenseReportData.wallets) {
+        for (const item of wallet.lineItems) {
+            total += parseFloat(item.actuals.value) || 0;
+        }
+    }
+    return { unit: "USDS", value: String(total) };
+}
+// USD stablecoins to include in net expense calculation
+const USD_STABLECOINS = new Set(["USDS", "USDC", "DAI"]);
+/**
+ * Sum of outbound USD stablecoin transactions that leave the Internal wallet grouping.
+ * Excludes Swap (token conversion) and Internal (inter-wallet transfers) flowTypes.
+ * Only counts USDS, USDC, and DAI — excludes sUSDS, EURe, SKY, MKR, etc.
+ */
+export function computeNetExpenseTxns(snapshotReportData) {
+    let total = 0;
+    for (const account of snapshotReportData.accounts) {
+        if (account.type !== "Internal")
+            continue;
+        for (const tx of account.transactions) {
+            if (tx.direction !== "OUTFLOW")
+                continue;
+            if (tx.flowType === "Swap" || tx.flowType === "Internal")
+                continue;
+            if (!USD_STABLECOINS.has(tx.amount.unit))
+                continue;
+            total += parseFloat(tx.amount.value.value) || 0;
         }
     }
-    return "";
+    return { unit: "USDS", value: String(total) };
 }

package/dist/subgraphs/budget-statements/resolvers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=resolvers.test.d.ts.map

package/dist/subgraphs/budget-statements/resolvers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvers.test.d.ts","sourceRoot":"","sources":["../../../subgraphs/budget-statements/resolvers.test.ts"],"names":[],"mappings":""}