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

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

@@ -0,0 +1,339 @@
+import { describe, it, expect } from "vitest";
+import { computeReportedActuals, computeNetExpenseTxns, extractIsoDate, getPeriodKey, getMonthKey, } from "./resolvers.js";
+const amt = (value) => ({
+    unit: "USDS",
+    value: String(value),
+});
+describe("computeReportedActuals", () => {
+    it("returns zero when there are no wallets", () => {
+        expect(computeReportedActuals({ wallets: [] })).toEqual(amt(0));
+    });
+    it("returns zero when wallets have no line items", () => {
+        expect(computeReportedActuals({
+            wallets: [{ lineItems: [] }, { lineItems: [] }],
+        })).toEqual(amt(0));
+    });
+    it("sums actuals from a single wallet", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: amt(100) },
+                        { actuals: amt(250.5) },
+                        { actuals: amt(49.5) },
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(400));
+    });
+    it("sums actuals across multiple wallets", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [{ actuals: amt(100) }, { actuals: amt(200) }],
+                },
+                {
+                    lineItems: [{ actuals: amt(300) }],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(600));
+    });
+    it("treats non-numeric values as zero", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: amt("abc") },
+                        { actuals: amt(100) },
+                        { actuals: amt("") },
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("handles negative actuals", () => {
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [{ actuals: amt(-50) }, { actuals: amt(200) }],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("sums actuals regardless of unit on line items (all currently USDS)", () => {
+        // In practice the expense report builder hardcodes unit="USDS",
+        // but if line items had different units, values are still summed as-is.
+        const result = computeReportedActuals({
+            wallets: [
+                {
+                    lineItems: [
+                        { actuals: { unit: "USDS", value: "100" } },
+                        { actuals: { unit: "DAI", value: "200" } },
+                        { actuals: { unit: "ETH", value: "1.5" } },
+                    ],
+                },
+            ],
+        });
+        // 100 + 200 + 1.5 = 301.5 (no conversion, sums raw values)
+        expect(result).toEqual(amt(301.5));
+    });
+});
+describe("extractIsoDate", () => {
+    it("extracts YYYY-MM-DD from full ISO string", () => {
+        expect(extractIsoDate("2025-09-01T00:00:00.000Z")).toBe("2025-09-01");
+    });
+    it("extracts YYYY-MM-DD from date-only string", () => {
+        expect(extractIsoDate("2025-09-01")).toBe("2025-09-01");
+    });
+    it("returns null for invalid input", () => {
+        expect(extractIsoDate("not-a-date")).toBeNull();
+        expect(extractIsoDate("")).toBeNull();
+    });
+});
+describe("getPeriodKey", () => {
+    it("creates key from ISO date strings", () => {
+        expect(getPeriodKey("2025-09-01T00:00:00.000Z", "2025-09-30T23:59:59.999Z")).toBe("2025-09-01_2025-09-30");
+    });
+    it("returns null when either date is missing", () => {
+        expect(getPeriodKey(null, "2025-09-30T00:00:00.000Z")).toBeNull();
+        expect(getPeriodKey("2025-09-01T00:00:00.000Z", null)).toBeNull();
+        expect(getPeriodKey(null, null)).toBeNull();
+    });
+});
+describe("getMonthKey", () => {
+    it("extracts month key from UTC midnight ISO string", () => {
+        expect(getMonthKey("2025-09-01T00:00:00.000Z")).toBe("SEP2025");
+    });
+    it("is not affected by timezone — UTC midnight stays in correct month", () => {
+        // This was the original bug: new Date("2025-09-01T00:00:00.000Z").getMonth()
+        // returns 7 (August) in UTC-3 because it becomes Aug 31 21:00 local time
+        expect(getMonthKey("2025-09-01T00:00:00.000Z")).toBe("SEP2025");
+        expect(getMonthKey("2025-01-01T00:00:00.000Z")).toBe("JAN2025");
+        expect(getMonthKey("2025-12-01T00:00:00.000Z")).toBe("DEC2025");
+    });
+    it("handles all months", () => {
+        const expected = [
+            "JAN",
+            "FEB",
+            "MAR",
+            "APR",
+            "MAY",
+            "JUN",
+            "JUL",
+            "AUG",
+            "SEP",
+            "OCT",
+            "NOV",
+            "DEC",
+        ];
+        for (let i = 0; i < 12; i++) {
+            const month = String(i + 1).padStart(2, "0");
+            expect(getMonthKey(`2026-${month}-15T12:00:00.000Z`)).toBe(`${expected[i]}2026`);
+        }
+    });
+    it("returns null for null or invalid input", () => {
+        expect(getMonthKey(null)).toBeNull();
+        expect(getMonthKey("not-a-date")).toBeNull();
+        expect(getMonthKey("")).toBeNull();
+    });
+});
+const makeTx = (direction, flowType, value, token = "USDS") => ({
+    direction,
+    flowType,
+    amount: { value: { unit: token, value: String(value) }, unit: token },
+});
+describe("computeNetExpenseTxns", () => {
+    it("returns zero when there are no accounts", () => {
+        expect(computeNetExpenseTxns({ accounts: [] })).toEqual(amt(0));
+    });
+    it("returns zero when there are no Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Source",
+                    transactions: [makeTx("OUTFLOW", "External", 500)],
+                },
+                {
+                    type: "Destination",
+                    transactions: [makeTx("OUTFLOW", "External", 300)],
+                },
+                {
+                    type: "External",
+                    transactions: [makeTx("OUTFLOW", "External", 200)],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("sums only OUTFLOW transactions from Internal accounts that leave the group", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100), // counted: leaves group
+                        makeTx("INFLOW", "TopUp", 500), // ignored: inflow
+                        makeTx("OUTFLOW", "Internal", 200), // ignored: stays within group
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("excludes Swap transactions", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100),
+                        makeTx("OUTFLOW", "Swap", 999), // excluded
+                        makeTx("OUTFLOW", "TopUp", 50),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("sums across multiple Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [makeTx("OUTFLOW", "External", 100)],
+                },
+                {
+                    type: "Internal",
+                    transactions: [makeTx("OUTFLOW", "Return", 200)],
+                },
+                {
+                    type: "Source",
+                    transactions: [makeTx("OUTFLOW", "External", 9999)], // ignored: not Internal
+                },
+            ],
+        });
+        expect(result).toEqual(amt(300));
+    });
+    it("excludes Internal flowType (inter-wallet transfers stay in group)", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "Internal", 500), // excluded: stays in group
+                        makeTx("OUTFLOW", "Internal", 300), // excluded: stays in group
+                        makeTx("OUTFLOW", "External", 100), // counted: leaves group
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("returns zero when all Internal txns are swaps, internal transfers, or inflows", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "Swap", 100), // excluded: swap
+                        makeTx("OUTFLOW", "Internal", 400), // excluded: stays in group
+                        makeTx("INFLOW", "External", 200), // excluded: inflow
+                        makeTx("INFLOW", "Swap", 300), // excluded: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("counts External, Return, and TopUp outflows as expenses leaving the group", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100), // counted: to external party
+                        makeTx("OUTFLOW", "Return", 200), // counted: returning to source
+                        makeTx("OUTFLOW", "TopUp", 50), // counted: funding destination
+                        makeTx("OUTFLOW", "Swap", 999), // excluded: token conversion
+                        makeTx("OUTFLOW", "Internal", 888), // excluded: inter-wallet
+                        makeTx("INFLOW", "TopUp", 5000), // excluded: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(350));
+    });
+    it("handles Internal accounts with no transactions", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [{ type: "Internal", transactions: [] }],
+        });
+        expect(result).toEqual(amt(0));
+    });
+    it("treats non-numeric amounts as zero", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", "bad"),
+                        makeTx("OUTFLOW", "External", 100),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+    it("only counts USD stablecoins (USDS, USDC, DAI)", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 500, "USDS"), // counted
+                        makeTx("OUTFLOW", "External", 200, "USDC"), // counted
+                        makeTx("OUTFLOW", "External", 100, "DAI"), // counted
+                        makeTx("OUTFLOW", "External", 1.5, "ETH"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 9999, "sUSDS"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 5000, "SKY"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 134, "MKR"), // excluded: not stablecoin
+                        makeTx("OUTFLOW", "External", 46, "EURe"), // excluded: not stablecoin
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(800));
+    });
+    it("excludes Swap even for stablecoin tokens", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100, "USDS"),
+                        makeTx("OUTFLOW", "Swap", 2000, "USDC"), // excluded: swap
+                        makeTx("OUTFLOW", "External", 50, "DAI"),
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(150));
+    });
+    it("ignores INFLOW of any token on Internal accounts", () => {
+        const result = computeNetExpenseTxns({
+            accounts: [
+                {
+                    type: "Internal",
+                    transactions: [
+                        makeTx("OUTFLOW", "External", 100, "USDS"),
+                        makeTx("INFLOW", "TopUp", 5000, "ETH"), // ignored: inflow
+                    ],
+                },
+            ],
+        });
+        expect(result).toEqual(amt(100));
+    });
+});

package/dist/subgraphs/budget-statements/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../subgraphs/budget-statements/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,MAAM,EAAE,YAqIpB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../subgraphs/budget-statements/schema.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,eAAO,MAAM,MAAM,EAAE,YA6IpB,CAAC"}

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

@@ -15,13 +15,21 @@ export const schema = gql `
   type BudgetStatement {
     id: OID!
     owner: BudgetStatementOwner!
+    operationalHubMember: OperationalHubMember
     month: String! ## JAN2026
     status: String!
     lastModifiedAtUtcIso: DateTime!
+    reportedActuals: Amount_Currency!
+    netExpenseTxns: Amount_Currency!
     snapshotReport: BudgetStatementSnapshotReport!
     expenseReport: BudgetStatementExpenseReport!
   }
 
+  type OperationalHubMember {
+    phid: PHID
+    name: String
+  }
+
   type BudgetStatementOwner {
     id: PHID!
     name: String!

package/dist/subgraphs/index.d.ts

@@ -1,5 +1,4 @@
 export * as InvoiceAddonSubgraph from "./invoice-addon/index.js";
 export * as AccTxsAddonSubgraph from "./acc-txs-addon/index.js";
 export * as BudgetStatementsSubgraph from "./budget-statements/index.js";
-export * as ResourcesServicesSubgraph from "./resources-services/index.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/subgraphs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../subgraphs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,oBAAoB,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,wBAAwB,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,yBAAyB,MAAM,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../subgraphs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,oBAAoB,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,mBAAmB,MAAM,0BAA0B,CAAC;AAChE,OAAO,KAAK,wBAAwB,MAAM,8BAA8B,CAAC"}

package/dist/subgraphs/index.js

@@ -1,4 +1,3 @@
 export * as InvoiceAddonSubgraph from "./invoice-addon/index.js";
 export * as AccTxsAddonSubgraph from "./acc-txs-addon/index.js";
 export * as BudgetStatementsSubgraph from "./budget-statements/index.js";
-export * as ResourcesServicesSubgraph from "./resources-services/index.js";

package/dist/subgraphs/invoice-addon/customResolvers.d.ts

@@ -1,9 +1,68 @@
-declare const pendingTransactions: Record<string, {
+import { type PaymentDetail, type TransferResult } from "../../scripts/invoice/gnosisTransactionBuilder.js";
+interface GnosisPaymentArgs {
+    chainName: string;
+    paymentDetails: PaymentDetail;
+    invoiceNo: string;
+}
+interface RequestFinancePaymentArgs {
+    paymentData: Record<string, unknown>;
+}
+interface GnosisPaymentResult {
+    success: boolean;
+    data?: TransferResult;
+    error?: string;
+}
+interface PendingTransaction {
     invoiceNo: string;
     chainName: string;
-    paymentDetails: any;
+    paymentDetails: PaymentDetail | PaymentDetail[];
     timestamp: number;
-}>;
+}
+interface DriveNode {
+    id: string;
+    documentType: string;
+}
+interface ReactorInstance {
+    getDrive(driveId: string): Promise<{
+        state: {
+            global: {
+                nodes: DriveNode[];
+            };
+        };
+    }>;
+    getDocument(driveId: string, documentId: string): Promise<{
+        state: {
+            global: {
+                invoiceNo: string;
+            };
+        };
+    }>;
+    addAction(driveId: string, documentId: string, action: unknown): Promise<void>;
+}
+interface AlchemyActivity {
+    category: string;
+    fromAddress: string;
+    toAddress: string;
+    rawContract: {
+        address: string;
+    };
+    hash?: string;
+    value?: number;
+}
+interface AlchemyWebhookPayload {
+    event?: {
+        activity?: AlchemyActivity | AlchemyActivity[];
+    };
+}
+interface WebhookRequest {
+    body: AlchemyWebhookPayload;
+    headers: Record<string, string | undefined>;
+}
+interface WebhookResponse {
+    status(code: number): WebhookResponse;
+    json(body: Record<string, unknown>): WebhookResponse;
+}
+declare const pendingTransactions: Record<string, PendingTransaction>;
 interface UploadInvoicePdfChunkArgs {
     chunk: string;
     chunkIndex: number;
@@ -11,23 +70,23 @@ interface UploadInvoicePdfChunkArgs {
     fileName: string;
     sessionId: string;
 }
-export declare const Invoice_processGnosisPayment: (_: any, args: any) => Promise<any>;
-export declare const Invoice_createRequestFinancePayment: (_: any, args: any) => Promise<{
+export declare const Invoice_processGnosisPayment: (_: unknown, args: GnosisPaymentArgs) => Promise<GnosisPaymentResult>;
+export declare const Invoice_createRequestFinancePayment: (_: unknown, args: RequestFinancePaymentArgs) => Promise<{
     success: boolean;
-    error: any;
+    error: string;
     data?: undefined;
 } | {
     success: boolean;
     data: {
         message: string;
-        response: any;
+        response: import("../../scripts/invoice/requestFinance.js").RequestFinanceResponse;
     };
     error?: undefined;
 }>;
-export declare const Invoice_uploadInvoicePdfChunk: (_: any, args: UploadInvoicePdfChunkArgs) => Promise<{
+export declare const Invoice_uploadInvoicePdfChunk: (_: unknown, args: UploadInvoicePdfChunkArgs) => Promise<{
     success: boolean;
     data: {
-        invoiceData: any;
+        invoiceData: Record<string, unknown>;
         processingMetadata: {
             provider: string;
             processingTimeMs: number;
@@ -47,8 +106,8 @@ export declare const Invoice_uploadInvoicePdfChunk: (_: any, args: UploadInvoice
     };
     error?: undefined;
 }>;
-export declare const setReactor: (reactorInstance: any) => void;
+export declare const setReactor: (reactorInstance: ReactorInstance) => void;
 export { pendingTransactions };
 export declare const cleanupOldPendingTransactions: () => void;
-export declare const handleWebhook: (req: any, res: any) => Promise<any>;
+export declare const handleWebhook: (req: WebhookRequest, res: WebhookResponse) => Promise<WebhookResponse>;
 //# sourceMappingURL=customResolvers.d.ts.map

package/dist/subgraphs/invoice-addon/customResolvers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"customResolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/invoice-addon/customResolvers.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,mBAAmB,EAAE,MAAM,CAC/B,MAAM,EACN;IACE,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,GAAG,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB,CACG,CAAC;AAQP,UAAU,yBAAyB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAaD,eAAO,MAAM,4BAA4B,GAAU,GAAG,GAAG,EAAE,MAAM,GAAG,iBA8EnE,CAAC;AAEF,eAAO,MAAM,mCAAmC,GAC9C,GAAG,GAAG,EACN,MAAM,GAAG;;;;;;;;;;;EAoCV,CAAC;AAEF,eAAO,MAAM,6BAA6B,GACxC,GAAG,GAAG,EACN,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;EAgFhC,CAAC;AAGF,eAAO,MAAM,UAAU,GAAI,iBAAiB,GAAG,SAE9C,CAAC;AAGF,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAG/B,eAAO,MAAM,6BAA6B,YA2BzC,CAAC;AAmDF,eAAO,MAAM,aAAa,GAAU,KAAK,GAAG,EAAE,KAAK,GAAG,iBAsLrD,CAAC"}
+{"version":3,"file":"customResolvers.d.ts","sourceRoot":"","sources":["../../../subgraphs/invoice-addon/customResolvers.ts"],"names":[],"mappings":"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"}

package/dist/subgraphs/invoice-addon/customResolvers.js

@@ -1,4 +1,4 @@
-import { executeTransferProposal } from "../../scripts/invoice/gnosisTransactionBuilder.js";
+import { executeTransferProposal, } from "../../scripts/invoice/gnosisTransactionBuilder.js";
 import { requestDirectPayment } from "../../scripts/invoice/requestFinance.js";
 import { actions } from "../../document-models/invoice/index.js";
 import { uploadPdfAndGetJsonClaude } from "../../scripts/invoice/pdfToClaudeAI.js";
@@ -238,24 +238,19 @@ const updateDocumentStatus = async (invoiceNo) => {
     }
     catch (error) {
         console.error(`Error finding document for invoice ${invoiceNo}:`, error);
-        return Promise.reject(error);
+        return Promise.reject(new Error(error));
     }
 };
 // Webhook handler method
 export const handleWebhook = async (req, res) => {
     try {
         console.log("Webhook received");
-        // Log all headers to debug
-        // console.log('Webhook request headers:', req.headers);
-        // console.log('Webhook request body:', req.body);
         // Get the request body and signature
         const payload = req.body;
         const rawBody = JSON.stringify(payload);
         const signature = req.headers["x-alchemy-signature"];
         if (!signature) {
             console.warn("Missing signature header");
-            // For testing, continue anyway
-            // return res.status(400).json({ error: 'Missing signature header' });
         }
         else {
             // Validate the signature
@@ -263,13 +258,8 @@ export const handleWebhook = async (req, res) => {
             const isValid = isValidSignatureForStringBody(rawBody, signature, signingKey);
             if (!isValid) {
                 console.warn("Invalid signature");
-                // For testing, continue anyway
-                // return res.status(401).json({ error: 'Invalid signature' });
             }
         }
-        // Process the webhook
-        // console.log('Processing webhook test button:', payload.event);
-        // console.log('Processing webhook payload:', payload.event.activity);
         // Check if this is a transaction confirmation webhook
         if (payload.event && payload.event.activity) {
             const activities = Array.isArray(payload.event.activity)
@@ -297,24 +287,19 @@ export const handleWebhook = async (req, res) => {
                     let matchedInvoiceNo = null;
                     let matchedTxHash = null;
                     for (const [txHash, txInfo] of Object.entries(pendingTransactions)) {
-                        const paymentDetails = Array.isArray(txInfo.paymentDetails)
+                        const paymentDetailsList = Array.isArray(txInfo.paymentDetails)
                             ? txInfo.paymentDetails
                             : [txInfo.paymentDetails];
-                        // Safe transactions may be sent from a different address than the Safe itself
-                        // So we'll focus on recipient, token, and amount
-                        for (const payment of paymentDetails) {
-                            // Cast payment to any to access its properties
-                            const typedPayment = payment;
+                        for (const payment of paymentDetailsList) {
                             // Check if recipient address matches
-                            if (typedPayment.payeeWallet &&
-                                typedPayment.payeeWallet.address.toLowerCase() === toAddress) {
+                            if (payment.payeeWallet &&
+                                payment.payeeWallet.address.toLowerCase() === toAddress) {
                                 // Check if token address matches
-                                if (typedPayment.token &&
-                                    typedPayment.token.evmAddress.toLowerCase() === tokenAddress) {
+                                if (payment.token &&
+                                    payment.token.evmAddress.toLowerCase() === tokenAddress) {
                                     // Check if amount is similar (allowing for some precision loss)
-                                    // Convert both to a common format for comparison
-                                    const expectedAmount = parseFloat(typedPayment.amount);
-                                    const actualAmount = parseFloat(tokenValue);
+                                    const expectedAmount = parseFloat(String(payment.amount));
+                                    const actualAmount = parseFloat(String(tokenValue));
                                     // Allow for a small difference due to precision issues
                                     const amountDifference = Math.abs(expectedAmount - actualAmount);
                                     const isAmountSimilar = amountDifference < 0.0001 ||
@@ -332,11 +317,11 @@ export const handleWebhook = async (req, res) => {
                                     }
                                 }
                                 else {
-                                    console.log(`Token addresses don't match. Expected: ${typedPayment.token?.evmAddress}, Actual: ${tokenAddress}`);
+                                    console.log(`Token addresses don't match. Expected: ${payment.token?.evmAddress}, Actual: ${tokenAddress}`);
                                 }
                             }
                             else {
-                                console.log(`Recipient addresses don't match. Expected: ${typedPayment.payeeWallet?.address}, Actual: ${toAddress}`);
+                                console.log(`Recipient addresses don't match. Expected: ${payment.payeeWallet?.address}, Actual: ${toAddress}`);
                             }
                         }
                         if (matchedInvoiceNo)