upshift-config 0.5.14

package/lib/services/layerzero/deposits.d.ts

@@ -0,0 +1,49 @@
+/**
+ * LayerZero Deposits Service
+ * Handles querying LayerZero USDC deposits from subgraphs
+ */
+import type { IAddress } from '../../types';
+export declare const LAYERZERO_VAULTS: {
+    coreUSDC: {
+        address: IAddress;
+        receiptToken: "coreusdc";
+        decimals: number;
+        hubChainId: number;
+        spokeChains: Record<number, IAddress>;
+        subgraphEndpoints: string[];
+    };
+    upUSDC: {
+        address: IAddress;
+        receiptToken: "upusdc";
+        decimals: number;
+        hubChainId: number;
+        spokeChains: Record<number, IAddress>;
+        subgraphEndpoints: string[];
+    };
+    earnAUSD: {
+        address: IAddress;
+        receiptToken: "earnausd";
+        decimals: number;
+        hubChainId: number;
+        spokeChains: Record<number, IAddress>;
+        subgraphEndpoints: string[];
+    };
+};
+export interface ILayerZeroDeposit {
+    assetAmt: string;
+    dstEid: string;
+    sender: string;
+    recipient: string;
+    shareAmt: string;
+    transactionHash_: string;
+    timestamp_: string;
+}
+/**
+ * Check if a vault address or symbol is a LayerZero vault
+ */
+export declare function isLayerZeroVault(vaultAddressOrSymbol: string): keyof typeof LAYERZERO_VAULTS | null;
+/**
+ * Query LayerZero deposits from the appropriate subgraph
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
+export declare function queryLayerZeroDeposits(vaultKey: keyof typeof LAYERZERO_VAULTS, wallet?: IAddress): Promise<ILayerZeroDeposit[]>;

package/lib/services/layerzero/deposits.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * LayerZero Deposits Service
+ * Handles querying LayerZero USDC deposits from subgraphs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAYERZERO_VAULTS = void 0;
+exports.isLayerZeroVault = isLayerZeroVault;
+exports.queryLayerZeroDeposits = queryLayerZeroDeposits;
+const fetcher_1 = require("../subgraph/fetcher");
+const utils_1 = require("./utils");
+// LayerZero vault addresses and their corresponding receipt tokens
+// spokeChains maps chainId -> shareOFT address (receipt token on that chain)
+exports.LAYERZERO_VAULTS = {
+    coreUSDC: {
+        address: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+        receiptToken: 'coreusdc',
+        decimals: 6, // USDC decimals
+        hubChainId: 1,
+        spokeChains: {
+            42161: '0x50a31ff4d57841681011837c17aa201c6a34203c', // Arbitrum
+            43114: '0x1FA931Bf85248aD2eDf0004DD9A284698358e708', // Avalanche
+            8453: '0x1fa931bf85248ad2edf0004dd9a284698358e708', // Base
+            146: '0x4bdd224fe59a3ae0b249125ad4c5b3126074c71b', // Sonic
+        },
+        subgraphEndpoints: [
+            'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-coreusdc/1.0.0/gn',
+        ],
+    },
+    upUSDC: {
+        address: '0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42',
+        receiptToken: 'upusdc',
+        decimals: 6, // USDC decimals
+        hubChainId: 1,
+        spokeChains: {
+            42161: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Arbitrum
+            43114: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34', // Avalanche
+            8453: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Base
+            146: '0x81971a3c359cfe74259cff1b46fb5f2112ddde34', // Sonic
+        },
+        subgraphEndpoints: [
+            'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-upusdc/1.0.0/gn',
+        ],
+    },
+    earnAUSD: {
+        address: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA',
+        receiptToken: 'earnausd',
+        decimals: 6,
+        hubChainId: 143,
+        spokeChains: {
+            1: '0xa6916b65c5e3fEdf46c0a2F59bff776e872C8992', // Ethereum
+        },
+        subgraphEndpoints: [
+            'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-earnAUSD/1.0.0/gn',
+            'https://api.goldsky.com/api/public/project_cm9g0xy3o4j6v01vd34r3hvv9/subgraphs/august-layerzero-earnausd/1.0.0/gn',
+        ],
+    },
+};
+/**
+ * Check if a vault address or symbol is a LayerZero vault
+ */
+function isLayerZeroVault(vaultAddressOrSymbol) {
+    const normalized = vaultAddressOrSymbol.toLowerCase();
+    // Check by address
+    if (normalized === exports.LAYERZERO_VAULTS.coreUSDC.address.toLowerCase() ||
+        normalized === 'coreusdc') {
+        return 'coreUSDC';
+    }
+    if (normalized === exports.LAYERZERO_VAULTS.upUSDC.address.toLowerCase() ||
+        normalized === 'upusdc') {
+        return 'upUSDC';
+    }
+    if (normalized === exports.LAYERZERO_VAULTS.earnAUSD.address.toLowerCase() ||
+        normalized === 'earnausd') {
+        return 'earnAUSD';
+    }
+    return null;
+}
+/**
+ * Validate GraphQL response structure
+ */
+function validateDepositResponse(result) {
+    if (!result || typeof result !== 'object') {
+        return false;
+    }
+    const r = result;
+    if (!r.data || typeof r.data !== 'object') {
+        return false;
+    }
+    const data = r.data;
+    if (!Array.isArray(data.depositeds)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Query LayerZero deposits from the appropriate subgraph
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
+async function queryLayerZeroDeposits(vaultKey, wallet) {
+    const vaultConfig = exports.LAYERZERO_VAULTS[vaultKey];
+    // Build GraphQL query (fetchSubgraph prepends "query " automatically)
+    let query = `GetDeposits {
+      depositeds(first: 1000) {
+        assetAmt
+        dstEid
+        sender
+        recipient
+        shareAmt
+        transactionHash_
+        timestamp_
+      }
+    }`;
+    // If wallet is provided, filter by sender
+    if (wallet) {
+        const senderBytes32 = (0, utils_1.addressToBytes32)(wallet);
+        query = `GetDeposits {
+        depositeds(first: 1000, where: { sender: "${senderBytes32}" }) {
+          assetAmt
+          dstEid
+          sender
+          recipient
+          shareAmt
+          transactionHash_
+          timestamp_
+        }
+      }`;
+    }
+    const endpoints = vaultConfig.subgraphEndpoints;
+    let lastError;
+    for (let i = 0; i < endpoints.length; i++) {
+        try {
+            const response = await (0, fetcher_1.fetchSubgraph)(endpoints[i], query);
+            // Only fall through to next endpoint on 404 (wrong URL casing)
+            if (response.status === 404 && i < endpoints.length - 1) {
+                continue;
+            }
+            if (!response.ok) {
+                throw new Error(`GraphQL request failed with status ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (result.errors) {
+                throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+            }
+            // Validate response structure
+            if (!validateDepositResponse(result)) {
+                throw new Error(`Invalid response structure from LayerZero subgraph. Expected data.depositeds array, got: ${JSON.stringify(result)}`);
+            }
+            return result.data.depositeds;
+        }
+        catch (error) {
+            lastError = error;
+            // Only continue to next endpoint on network-level failures; re-throw application errors immediately
+            if (i >= endpoints.length - 1)
+                break;
+        }
+    }
+    // All endpoints failed — throw the last error with context
+    if (lastError instanceof Error) {
+        const enhancedError = new Error(`Failed to fetch LayerZero deposits for ${vaultKey}: ${lastError.message}`);
+        enhancedError.stack = lastError.stack;
+        throw enhancedError;
+    }
+    throw new Error(`Failed to fetch LayerZero deposits for ${vaultKey}: ${String(lastError)}`);
+}
+//# sourceMappingURL=deposits.js.map

package/lib/services/layerzero/redeems.d.ts

@@ -0,0 +1,20 @@
+/**
+ * LayerZero Redeems Service
+ * Handles querying LayerZero earnAUSD redeems from subgraphs
+ */
+import type { IAddress } from '../../types';
+export interface ILayerZeroRedeem {
+    id: string;
+    recipient: string;
+    sender: string;
+    shareAmt: string;
+    transactionHash_: string;
+    timestamp_: string;
+}
+/**
+ * Query LayerZero redeems for earnAUSD from the subgraph.
+ * Uses the same earnAUSD subgraph endpoints as deposits — the subgraph indexes
+ * both Deposited and Redeemed events from the same contract.
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
+export declare function queryLayerZeroRedeems(wallet?: IAddress): Promise<ILayerZeroRedeem[]>;

package/lib/services/layerzero/redeems.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * LayerZero Redeems Service
+ * Handles querying LayerZero earnAUSD redeems from subgraphs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryLayerZeroRedeems = queryLayerZeroRedeems;
+const fetcher_1 = require("../subgraph/fetcher");
+const deposits_1 = require("./deposits");
+const utils_1 = require("./utils");
+/**
+ * Validate GraphQL response structure for redeems
+ */
+function validateRedeemResponse(result) {
+    if (!result || typeof result !== 'object') {
+        return false;
+    }
+    const r = result;
+    if (!r.data || typeof r.data !== 'object') {
+        return false;
+    }
+    const data = r.data;
+    if (!Array.isArray(data.redeemeds)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Query LayerZero redeems for earnAUSD from the subgraph.
+ * Uses the same earnAUSD subgraph endpoints as deposits — the subgraph indexes
+ * both Deposited and Redeemed events from the same contract.
+ * @throws Error if the GraphQL request fails or returns invalid data
+ */
+async function queryLayerZeroRedeems(wallet) {
+    const vaultConfig = deposits_1.LAYERZERO_VAULTS.earnAUSD;
+    let query = `GetRedeems {
+      redeemeds(first: 1000) {
+        id
+        recipient
+        sender
+        shareAmt
+        transactionHash_
+        timestamp_
+      }
+    }`;
+    if (wallet) {
+        const senderBytes32 = (0, utils_1.addressToBytes32)(wallet);
+        query = `GetRedeems {
+        redeemeds(first: 1000, where: { sender: "${senderBytes32}" }) {
+          id
+          recipient
+          sender
+          shareAmt
+          transactionHash_
+          timestamp_
+        }
+      }`;
+    }
+    const endpoints = vaultConfig.subgraphEndpoints;
+    let lastError;
+    for (let i = 0; i < endpoints.length; i++) {
+        try {
+            const response = await (0, fetcher_1.fetchSubgraph)(endpoints[i], query);
+            if (response.status === 404 && i < endpoints.length - 1) {
+                continue;
+            }
+            if (!response.ok) {
+                throw new Error(`GraphQL request failed with status ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
+            if (result.errors) {
+                throw new Error(`GraphQL errors: ${JSON.stringify(result.errors)}`);
+            }
+            if (!validateRedeemResponse(result)) {
+                throw new Error(`Invalid response structure from LayerZero subgraph. Expected data.redeemeds array, got: ${JSON.stringify(result)}`);
+            }
+            return result.data.redeemeds;
+        }
+        catch (error) {
+            lastError = error;
+            if (i >= endpoints.length - 1)
+                break;
+        }
+    }
+    if (lastError instanceof Error) {
+        const enhancedError = new Error(`Failed to fetch LayerZero redeems for earnAUSD: ${lastError.message}`);
+        enhancedError.stack = lastError.stack;
+        throw enhancedError;
+    }
+    throw new Error(`Failed to fetch LayerZero redeems for earnAUSD: ${String(lastError)}`);
+}
+//# sourceMappingURL=redeems.js.map

package/lib/services/layerzero/utils.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Shared LayerZero utilities
+ */
+/**
+ * Convert Ethereum address to bytes32 format (left-padded with zeros)
+ * Used by LayerZero subgraph queries where addresses are stored in bytes32 format.
+ * @throws {Error} If address format is invalid
+ */
+export declare function addressToBytes32(address: string): string;

package/lib/services/layerzero/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+/**
+ * Shared LayerZero utilities
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressToBytes32 = addressToBytes32;
+/**
+ * Convert Ethereum address to bytes32 format (left-padded with zeros)
+ * Used by LayerZero subgraph queries where addresses are stored in bytes32 format.
+ * @throws {Error} If address format is invalid
+ */
+function addressToBytes32(address) {
+    // Validate address format
+    if (!address.match(/^0x[a-fA-F0-9]{40}$/)) {
+        throw new Error(`Invalid Ethereum address format: ${address}. Expected format: 0x followed by 40 hexadecimal characters.`);
+    }
+    // Remove 0x prefix and convert to lowercase
+    const cleanAddress = address.replace(/^0x/i, '').toLowerCase();
+    // Pad with 24 zeros (12 bytes) to make it 32 bytes total
+    return '0x' + '0'.repeat(24) + cleanAddress;
+}
+//# sourceMappingURL=utils.js.map

package/lib/services/octavfi/fetcher.d.ts

@@ -0,0 +1,9 @@
+import type { IOctavfiPortfolio } from './types';
+/**
+ * Fetches portfolio data from Octavfi API.
+ * Note: The API currently doesn't support multiple addresses in a single request,
+ * so individual requests are made for each address.
+ * @param addresses - Array of addresses to fetch data for.
+ * @returns Array of portfolio data (may be empty if all requests fail).
+ */
+export declare function fetchOctavfiPortfolios(addresses: string[]): Promise<IOctavfiPortfolio[]>;

package/lib/services/octavfi/fetcher.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchOctavfiPortfolios = fetchOctavfiPortfolios;
+const ethers_1 = require("ethers");
+const utils_1 = require("../../adapters/solana/utils");
+const core_1 = require("../../core");
+const BASE_URL = 'https://api.octav.fi';
+const OCTAVFI_API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwczovL2hhc3VyYS5pby9qd3QvY2xhaW1zIjp7IngtaGFzdXJhLWRlZmF1bHQtcm9sZSI6InVzZXIiLCJ4LWhhc3VyYS1hbGxvd2VkLXJvbGVzIjpbInVzZXIiXSwieC1oYXN1cmEtdXNlci1pZCI6ImF1Z3VzdDEyMjM0In19.zaMUtrtdC82uaDh6XSZrsneEcKO3PFOE6FyX3G-MR6c';
+/**
+ * Filters addresses to only include EVM and Solana wallet addresses.
+ * Excludes Sui addresses and other non-supported address formats.
+ *
+ * @param addresses - Array of addresses to filter
+ * @returns Array containing only EVM and Solana addresses
+ */
+function filterEvmAndSolanaAddresses(addresses) {
+    return addresses.filter((address) => {
+        if (!address || typeof address !== 'string')
+            return false;
+        if ((0, ethers_1.isAddress)(address)) {
+            return true;
+        }
+        if (utils_1.SolanaUtils.isSolanaAddress(address)) {
+            return true;
+        }
+        core_1.Logger.log.info('filterEvmAndSolanaAddresses.excluded', { address });
+        return false;
+    });
+}
+/**
+ * Fetches portfolio data for a single address from Octavfi API.
+ * @param address - Single address to fetch data for.
+ * @returns Portfolio data or null if request fails.
+ */
+async function fetchSinglePortfolio(address) {
+    try {
+        const response = await fetch(`${BASE_URL}/v1/portfolio?addresses=${address}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${OCTAVFI_API_KEY}`,
+            },
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            core_1.Logger.log.error('fetchSinglePortfolio', new Error(`HTTP ${response.status} ${response.statusText}: ${errorText}`), {
+                address,
+                status: response.status,
+                statusText: response.statusText,
+            });
+            return null;
+        }
+        const data = await response.json();
+        if (!data || typeof data !== 'object') {
+            core_1.Logger.log.error('fetchSinglePortfolio.unexpected-type', new Error(`unexpected response type: ${typeof data}`), { address });
+            return null;
+        }
+        if (data.error) {
+            core_1.Logger.log.error('fetchSinglePortfolio.api-error', new Error(String(data.error)), { address });
+            return null;
+        }
+        // Handle nested array response: [[portfolio]] or [portfolio] or portfolio
+        let portfolio = data;
+        if (Array.isArray(data)) {
+            if (data.length > 0 && Array.isArray(data[0])) {
+                // Nested array: [[portfolio]]
+                portfolio = data[0][0];
+            }
+            else if (data.length > 0) {
+                // Single array: [portfolio]
+                portfolio = data[0];
+            }
+            else {
+                return null;
+            }
+        }
+        // Return raw Octavfi data (transformation should happen separately when needed)
+        return portfolio;
+    }
+    catch (error) {
+        core_1.Logger.log.error('fetchSinglePortfolio', error, { address });
+        return null;
+    }
+}
+/**
+ * Fetches portfolio data from Octavfi API.
+ * Note: The API currently doesn't support multiple addresses in a single request,
+ * so individual requests are made for each address.
+ * @param addresses - Array of addresses to fetch data for.
+ * @returns Array of portfolio data (may be empty if all requests fail).
+ */
+async function fetchOctavfiPortfolios(addresses) {
+    const filteredAddresses = filterEvmAndSolanaAddresses(addresses);
+    if (filteredAddresses.length === 0) {
+        return [];
+    }
+    // Fetch portfolios for each address in parallel
+    const portfolioPromises = filteredAddresses.map((address) => fetchSinglePortfolio(address));
+    const portfolios = await Promise.all(portfolioPromises);
+    // Filter out null results (failed requests)
+    return portfolios.filter((portfolio) => portfolio !== null);
+}
+//# sourceMappingURL=fetcher.js.map

package/lib/services/octavfi/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetcher';
+export * from './types';
+export * from './utils';

package/lib/services/octavfi/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./fetcher"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);
+//# sourceMappingURL=index.js.map

package/lib/services/octavfi/types.d.ts

@@ -0,0 +1,34 @@
+import type { IAddress } from '../../types';
+export type IOctavfiEndpoint = 'portfolio';
+export interface IOctavfiAsset {
+    balance: string;
+    symbol: string;
+    price: string;
+    value: string;
+    contractAddress?: IAddress;
+    chain: string;
+}
+export interface IOctavfiProtocolBreakdown {
+    key: string;
+    name: string;
+    value: string;
+    assets: IOctavfiAsset[];
+}
+export interface IOctavfiChainBreakdown {
+    key: string;
+    name: string;
+    value: string;
+    protocols: string[];
+}
+export interface IOctavfiPortfolio {
+    address: IAddress;
+    cashBalance: string;
+    dailyIncome: string;
+    dailyExpense: string;
+    fees: string;
+    feesFiat: string;
+    lastUpdated: string;
+    networth: string;
+    assetByProtocols: Record<string, IOctavfiProtocolBreakdown>;
+    chains: Record<string, IOctavfiChainBreakdown>;
+}

package/lib/services/octavfi/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/services/octavfi/utils.d.ts

@@ -0,0 +1,16 @@
+import type { IOctavfiPortfolio } from './types';
+import type { IDebankNormalizedResponse } from '../debank/utils';
+/**
+ * Transforms Octavfi portfolio response to DeBank-compatible format.
+ * This allows Solana addresses to use Octavfi data while maintaining
+ * compatibility with existing DeBank parsing functions.
+ *
+ * @param octavfiPortfolio - Octavfi portfolio response
+ * @returns DeBank-compatible response structure
+ */
+export declare function transformOctavfiToDebank(octavfiPortfolio: IOctavfiPortfolio | null | undefined): IDebankNormalizedResponse;
+/**
+ * Transforms multiple Octavfi portfolios to DeBank format.
+ * Used when fetching multiple addresses.
+ */
+export declare function transformOctavfiPortfoliosToDebank(portfolios: IOctavfiPortfolio[]): any[];