@powerhousedao/contributor-billing 0.1.30 → 0.1.32

package/dist/scripts/alchemy/alchemyHelpers.js

@@ -0,0 +1,116 @@
+/**
+ * Utility functions for Alchemy API integration
+ */
+/**
+ * Retry mechanism with exponential backoff (following gnosis pattern)
+ */
+export async function withRetry(fn, maxRetries = 3, initialDelay = 1000, operationName = "Alchemy API call") {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            const isRateLimit = error?.message?.includes("Too Many Requests") ||
+                error?.message?.includes("429") ||
+                error?.status === 429;
+            if (isRateLimit && attempt < maxRetries - 1) {
+                const waitTime = initialDelay * Math.pow(2, attempt);
+                console.log(`[${operationName}] Rate limited, retrying in ${waitTime}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, waitTime));
+                continue;
+            }
+            // If it's not a rate limit error or we've exhausted retries, throw
+            if (attempt === maxRetries - 1) {
+                console.error(`[${operationName}] Max retries exceeded:`, error?.message);
+            }
+            throw error;
+        }
+    }
+    throw new Error(`${operationName}: Max retries exceeded`);
+}
+/**
+ * Validate Ethereum address format
+ */
+export function isValidEthereumAddress(address) {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+/**
+ * Convert Alchemy transaction to document model format
+ */
+export function convertToTransactionEntry(transfer, userAddress, blockTimestamp) {
+    // Convert value based on decimals for ERC20 tokens
+    let value;
+    if (transfer.category === "erc20" && transfer.rawContract.decimal) {
+        const decimals = parseInt(transfer.rawContract.decimal, 16);
+        const rawValue = parseInt(transfer.rawContract.value, 16);
+        value = (rawValue / Math.pow(10, decimals)).toString();
+    }
+    else {
+        value = transfer.value?.toString() || transfer.rawContract.value || "0";
+    }
+    const token = transfer.asset || "ETH";
+    // Determine direction and counterparty based on transaction flow
+    const userAddressLower = userAddress.toLowerCase();
+    const fromAddressLower = transfer.from.toLowerCase();
+    const toAddressLower = transfer.to.toLowerCase();
+    let direction;
+    let counterParty;
+    if (toAddressLower === userAddressLower) {
+        // Money coming INTO user's account
+        direction = "INFLOW";
+        counterParty = transfer.from; // The sender is the counterparty
+    }
+    else if (fromAddressLower === userAddressLower) {
+        // Money going OUT of user's account
+        direction = "OUTFLOW";
+        counterParty = transfer.to; // The receiver is the counterparty
+    }
+    else {
+        // This shouldn't happen for user-specific transactions, but fallback to OUTFLOW
+        direction = "OUTFLOW";
+        counterParty = transfer.from;
+    }
+    // Use provided timestamp or fallback to current time
+    const datetime = blockTimestamp
+        ? new Date(blockTimestamp).toISOString()
+        : new Date().toISOString();
+    // Extract year from the actual transaction date for accounting period
+    const transactionDate = new Date(blockTimestamp || Date.now());
+    // Validation - throw error if critical fields are undefined
+    if (!direction) {
+        throw new Error(`Direction is undefined for transaction ${transfer.hash}. From: ${transfer.from}, To: ${transfer.to}, User: ${userAddress}`);
+    }
+    if (!transfer.from) {
+        throw new Error(`From address is undefined for transaction ${transfer.hash}`);
+    }
+    if (!transfer.to) {
+        throw new Error(`To address is undefined for transaction ${transfer.hash}`);
+    }
+    return {
+        uniqueId: transfer.uniqueId,
+        counterParty,
+        amount: {
+            unit: token,
+            value: value,
+        },
+        txHash: transfer.hash,
+        token: token,
+        blockNumber: parseInt(transfer.blockNum, 16),
+        datetime: datetime,
+        accountingPeriod: transactionDate.getFullYear().toString(),
+        from: transfer.from,
+        to: transfer.to,
+        direction,
+    };
+}
+/**
+ * Validate environment variables
+ */
+export function validateEnvironment() {
+    const apiKey = process.env.ALCHEMY_API_KEY;
+    if (!apiKey) {
+        throw new Error("ALCHEMY_API_KEY environment variable is not set");
+    }
+    const network = process.env.ALCHEMY_NETWORK || "mainnet";
+    return { apiKey, network };
+}

package/dist/scripts/alchemy/alchemyTypes.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Type definitions for Alchemy API integration
+ */
+export interface AlchemyConfig {
+    apiKey: string;
+    network: string;
+}
+export interface AlchemyAssetTransfer {
+    blockNum: string;
+    uniqueId: string;
+    hash: string;
+    from: string;
+    to: string;
+    value?: number;
+    erc721TokenId?: string;
+    erc1155Metadata?: any;
+    tokenId?: string;
+    asset: string;
+    category: "external" | "internal" | "erc20" | "erc721" | "erc1155";
+    rawContract: {
+        value: string;
+        address: string;
+        decimal: string;
+    };
+}
+export interface AlchemyResponse {
+    jsonrpc: string;
+    id: number;
+    result: {
+        transfers: AlchemyAssetTransfer[];
+        pageKey?: string;
+    };
+}
+export interface AlchemyErrorResponse {
+    jsonrpc: string;
+    id: number;
+    error: {
+        code: number;
+        message: string;
+    };
+}
+export interface GetAssetTransfersParams {
+    fromBlock?: string;
+    toBlock?: string;
+    fromAddress?: string;
+    toAddress?: string;
+    contractAddresses?: string[];
+    category?: ("external" | "internal" | "erc20" | "erc721" | "erc1155")[];
+    maxCount?: string;
+    pageKey?: string;
+    excludeZeroValue?: boolean;
+    withMetadata?: boolean;
+}
+export declare const SUPPORTED_TOKEN_CONTRACTS: {
+    readonly USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48";
+    readonly USDT: "0xdac17f958d2ee523a2206206994597c13d831ec7";
+    readonly USDS: "0xdc035d45d973e3ec169d2276ddab16f1e407384f";
+    readonly SUSDS: "0xa3931d71877c0e7a3148cb7eb4463524fec27fbd";
+    readonly DAI: "0x6b175474e89094c44da98b954eedeac495271d0f";
+    readonly MKR: "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2";
+    readonly SKY: "0x56072c95faa701256059aa122697b133aded9279";
+    readonly SPK: "0xc20059e0317de91738d13af027dfc4a50781b066";
+    readonly WETH: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2";
+    readonly EURe: "0x3231cb76718cdef2155fc47b5286d82e6eda273f";
+};
+export declare const NATIVE_TOKENS: readonly ["ETH"];
+export declare const TRACKED_TOKENS: readonly [...string[], "ETH"];
+export declare const getAllTokenContracts: () => ("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48" | "0xdac17f958d2ee523a2206206994597c13d831ec7" | "0xdc035d45d973e3ec169d2276ddab16f1e407384f" | "0xa3931d71877c0e7a3148cb7eb4463524fec27fbd" | "0x6b175474e89094c44da98b954eedeac495271d0f" | "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2" | "0x56072c95faa701256059aa122697b133aded9279" | "0xc20059e0317de91738d13af027dfc4a50781b066" | "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2" | "0x3231cb76718cdef2155fc47b5286d82e6eda273f")[];
+export interface BlockResponse {
+    jsonrpc: string;
+    id: number;
+    result: {
+        timestamp: string;
+        [key: string]: any;
+    };
+}
+export interface TransactionEntry {
+    uniqueId: string;
+    counterParty: string;
+    amount: {
+        unit: string;
+        value: string;
+    };
+    txHash: string;
+    token: string;
+    blockNumber?: number;
+    datetime: string;
+    accountingPeriod: string;
+    from: string;
+    to: string;
+    direction: "INFLOW" | "OUTFLOW";
+}
+//# sourceMappingURL=alchemyTypes.d.ts.map

package/dist/scripts/alchemy/alchemyTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alchemyTypes.d.ts","sourceRoot":"","sources":["../../../scripts/alchemy/alchemyTypes.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,eAAe,CAAC,EAAE,GAAG,CAAC;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC;IACnE,WAAW,EAAE;QACX,KAAK,EAAE,MAAM,CAAC;QACd,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE;QACN,SAAS,EAAE,oBAAoB,EAAE,CAAC;QAClC,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE;QACL,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC7B,QAAQ,CAAC,EAAE,CAAC,UAAU,GAAG,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAC,EAAE,CAAC;IACxE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAGD,eAAO,MAAM,yBAAyB;;;;;;;;;;;CAW5B,CAAC;AAGX,eAAO,MAAM,aAAa,kBAAmB,CAAC;AAG9C,eAAO,MAAM,cAAc,+BAGjB,CAAC;AAGX,eAAO,MAAM,oBAAoB,+dACS,CAAC;AAE3C,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE;QACN,SAAS,EAAE,MAAM,CAAC;QAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;KACpB,CAAC;CACH;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC"}

package/dist/scripts/alchemy/alchemyTypes.js

@@ -0,0 +1,25 @@
+/**
+ * Type definitions for Alchemy API integration
+ */
+// ERC20 token contract addresses (Ethereum mainnet)
+export const SUPPORTED_TOKEN_CONTRACTS = {
+    USDC: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    USDT: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    USDS: "0xdc035d45d973e3ec169d2276ddab16f1e407384f",
+    SUSDS: "0xa3931d71877c0e7a3148cb7eb4463524fec27fbd",
+    DAI: "0x6b175474e89094c44da98b954eedeac495271d0f",
+    MKR: "0x9f8f72aa9304c8b593d555f12ef6589cc3a579a2",
+    SKY: "0x56072c95faa701256059aa122697b133aded9279",
+    SPK: "0xc20059e0317de91738d13af027dfc4a50781b066",
+    WETH: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+    EURe: "0x3231cb76718cdef2155fc47b5286d82e6eda273f",
+};
+// Native tokens that don't have contract addresses (fetched via "external" category)
+export const NATIVE_TOKENS = ["ETH"];
+// All tracked tokens (ERC20 + native) for use in snapshots and other features
+export const TRACKED_TOKENS = [
+    ...Object.keys(SUPPORTED_TOKEN_CONTRACTS),
+    ...NATIVE_TOKENS,
+];
+// Helper to get all ERC20 contract addresses as an array
+export const getAllTokenContracts = () => Object.values(SUPPORTED_TOKEN_CONTRACTS);

package/dist/scripts/invoice/pdfToClaudeAI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pdfToClaudeAI.d.ts","sourceRoot":"","sources":["../../../scripts/invoice/pdfToClaudeAI.ts"],"names":[],"mappings":"AAGA,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,MAAM;;GAyP/D"}
+{"version":3,"file":"pdfToClaudeAI.d.ts","sourceRoot":"","sources":["../../../scripts/invoice/pdfToClaudeAI.ts"],"names":[],"mappings":"AA4LA,wBAAsB,yBAAyB,CAAC,QAAQ,EAAE,MAAM;;GAoR/D"}

package/dist/scripts/invoice/pdfToClaudeAI.js

@@ -1,5 +1,164 @@
 import { generateId } from "document-model";
 import { autoTagLineItems } from "./autoTagging.js";
+/**
+ * Attempts to repair truncated JSON by closing unclosed brackets and braces.
+ * This handles cases where Claude's response gets cut off due to max_tokens.
+ */
+function repairTruncatedJson(jsonString) {
+    let repaired = jsonString.trim();
+    // Find the last complete JSON element (object or value in array)
+    // We need to truncate at the last complete element before adding closing brackets
+    repaired = truncateToLastCompleteElement(repaired);
+    // Count unclosed brackets and braces
+    let openBraces = 0;
+    let openBrackets = 0;
+    let inString = false;
+    let escapeNext = false;
+    for (let i = 0; i < repaired.length; i++) {
+        const char = repaired[i];
+        if (escapeNext) {
+            escapeNext = false;
+            continue;
+        }
+        if (char === "\\") {
+            escapeNext = true;
+            continue;
+        }
+        if (char === '"') {
+            inString = !inString;
+            continue;
+        }
+        if (!inString) {
+            if (char === "{")
+                openBraces++;
+            else if (char === "}")
+                openBraces--;
+            else if (char === "[")
+                openBrackets++;
+            else if (char === "]")
+                openBrackets--;
+        }
+    }
+    // Close any unclosed arrays and objects
+    // Close arrays first (they're usually inside objects)
+    while (openBrackets > 0) {
+        repaired += "]";
+        openBrackets--;
+    }
+    // Then close objects
+    while (openBraces > 0) {
+        repaired += "}";
+        openBraces--;
+    }
+    return repaired;
+}
+/**
+ * Truncates JSON string to the last complete element.
+ * Handles cases where truncation occurs mid-string, mid-object, or mid-array.
+ */
+function truncateToLastCompleteElement(json) {
+    // Find the last closing brace or bracket that represents a complete element
+    // We scan backwards to find the last complete object "}" or complete array element
+    let depth = 0;
+    let inString = false;
+    let lastCompleteObjectEnd = -1;
+    for (let i = 0; i < json.length; i++) {
+        const char = json[i];
+        const prevChar = i > 0 ? json[i - 1] : "";
+        // Handle escape sequences
+        if (char === '"' && prevChar !== "\\") {
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === "{" || char === "[") {
+            depth++;
+        }
+        else if (char === "}" || char === "]") {
+            depth--;
+            // Track the position after closing braces at depth 1 (inside the lineItems array)
+            // or after any closing brace that's followed by a comma or end
+            if (char === "}") {
+                lastCompleteObjectEnd = i + 1;
+            }
+        }
+    }
+    // If we found a complete object, check if there's incomplete content after it
+    if (lastCompleteObjectEnd > 0 && lastCompleteObjectEnd < json.length) {
+        const remainder = json.substring(lastCompleteObjectEnd).trim();
+        // If what's left starts with a comma and then has incomplete content,
+        // we should truncate there
+        if (remainder.startsWith(",")) {
+            const afterComma = remainder.substring(1).trim();
+            // Check if the content after the comma is incomplete (starts with { but doesn't close)
+            if (afterComma.startsWith("{") || afterComma.startsWith('"')) {
+                // Check if this new element is complete
+                let testDepth = 0;
+                let testInString = false;
+                let isComplete = false;
+                for (let i = 0; i < afterComma.length; i++) {
+                    const char = afterComma[i];
+                    const prevChar = i > 0 ? afterComma[i - 1] : "";
+                    if (char === '"' && prevChar !== "\\") {
+                        testInString = !testInString;
+                        continue;
+                    }
+                    if (testInString)
+                        continue;
+                    if (char === "{" || char === "[")
+                        testDepth++;
+                    else if (char === "}" || char === "]") {
+                        testDepth--;
+                        if (testDepth === 0 && char === "}") {
+                            isComplete = true;
+                            break;
+                        }
+                    }
+                }
+                // If the element after the comma is incomplete, truncate before the comma
+                if (!isComplete) {
+                    return json.substring(0, lastCompleteObjectEnd);
+                }
+            }
+        }
+    }
+    // Alternative approach: find the last complete line item by looking for the pattern
+    // "},\n    {" and ensure the last one is complete
+    const lineItemPattern = /\},\s*\{[^}]*$/;
+    const match = json.match(lineItemPattern);
+    if (match && match.index !== undefined) {
+        // There's an incomplete line item at the end
+        // Truncate just before the comma that starts the incomplete item
+        const truncateAt = match.index + 1; // Keep the closing }
+        return json.substring(0, truncateAt);
+    }
+    // Check if we're in the middle of a string value
+    // Count quotes to see if we're inside a string
+    let quoteCount = 0;
+    for (let i = 0; i < json.length; i++) {
+        if (json[i] === '"' && (i === 0 || json[i - 1] !== "\\")) {
+            quoteCount++;
+        }
+    }
+    // If odd number of quotes, we're inside a string - find and remove the incomplete part
+    if (quoteCount % 2 === 1) {
+        // Find the last property that started (look for last '": ' or '":')
+        const lastPropStart = Math.max(json.lastIndexOf('": "'), json.lastIndexOf('":"'));
+        if (lastPropStart > 0) {
+            // Find the comma or opening brace before this property
+            let searchFrom = lastPropStart;
+            while (searchFrom > 0 && json[searchFrom] !== "," && json[searchFrom] !== "{") {
+                searchFrom--;
+            }
+            if (json[searchFrom] === ",") {
+                // Remove the incomplete property by truncating at the comma
+                return json.substring(0, searchFrom);
+            }
+        }
+    }
+    return json;
+}
 export async function uploadPdfAndGetJsonClaude(inputDoc) {
     try {
         console.log("Starting PDF upload and processing with Claude AI");
@@ -166,10 +325,12 @@ Please analyze this PDF invoice document and extract the following information i
 }
 
 Extract only the data that is clearly visible in the PDF. If a field is not present, use null. Be very careful with numbers - preserve the exact values without modification. For dates, convert to YYYY-MM-DD format. For currencies, use standard 3-letter codes (USD, EUR, GBP, etc.).
+
+IMPORTANT: You MUST output valid, complete JSON. Do not truncate or abbreviate the output. Include all line items.
 `;
         const requestBody = {
-            model: "claude-haiku-4-5-20251001",
-            max_tokens: 4000,
+            model: "claude-sonnet-4-20250514",
+            max_tokens: 32000,
             messages: [
                 {
                     role: "user",
@@ -206,6 +367,11 @@ Extract only the data that is clearly visible in the PDF. If a field is not pres
         }
         const result = await response.json();
         console.log("PDF processed successfully with Claude AI");
+        // Check if the response was truncated due to max_tokens
+        const stopReason = result.stop_reason;
+        if (stopReason === "max_tokens") {
+            console.warn("Warning: Claude response was truncated due to max_tokens limit");
+        }
         // Extract JSON from Claude's response
         const responseText = result.content[0]?.text;
         if (!responseText) {
@@ -218,7 +384,9 @@ Extract only the data that is clearly visible in the PDF. If a field is not pres
             const jsonMatch = responseText.match(/```json\s*([\s\S]*?)\s*```/) ||
                 responseText.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
-                const jsonString = jsonMatch[1] || jsonMatch[0];
+                let jsonString = jsonMatch[1] || jsonMatch[0];
+                // Attempt to repair truncated JSON if needed
+                jsonString = repairTruncatedJson(jsonString);
                 invoiceData = JSON.parse(jsonString);
             }
             else {
@@ -229,7 +397,21 @@ Extract only the data that is clearly visible in the PDF. If a field is not pres
         catch (parseError) {
             console.error("Failed to parse Claude response as JSON:", parseError);
             console.error("Response text:", responseText);
-            throw new Error("Failed to parse Claude response as valid JSON");
+            // Try one more time with aggressive repair
+            try {
+                const jsonMatch = responseText.match(/\{[\s\S]*/);
+                if (jsonMatch) {
+                    const repairedJson = repairTruncatedJson(jsonMatch[0]);
+                    invoiceData = JSON.parse(repairedJson);
+                    console.log("Successfully repaired truncated JSON");
+                }
+                else {
+                    throw new Error("Failed to parse Claude response as valid JSON");
+                }
+            }
+            catch {
+                throw new Error("Failed to parse Claude response as valid JSON");
+            }
         }
         // Process the invoice data to ensure it matches our expected format
         const processedInvoiceData = await processClaudeInvoiceData(invoiceData);