@upshiftfinance/sdk 0.0.0-stage → 0.2.0

package/lib/services/debank/utils.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVaultLevelDebank = parseVaultLevelDebank;
+exports.getVaultExposure = getVaultExposure;
+exports.parseLoanLevelDebank = parseLoanLevelDebank;
+const core_1 = require("../../core");
+const core_2 = require("../../core/helpers/core");
+function addToTokenExposure(token, tokenExposure, exposureType, protocol, exposurePerCategory, netValue, borrower, poolId) {
+    const usdAmount = Number(token?.price || 0) * Number(token?.amount);
+    // Dust filter applies uniformly to every exposure type.
+    if (!(0, core_2.filterOutBySize)(usdAmount))
+        return;
+    if (exposureType === 'borrow') {
+        netValue.value -= usdAmount;
+    }
+    else {
+        netValue.value += usdAmount;
+    }
+    // Merge into an existing row only when the symbol, the exposure type AND
+    // the protocol all match: the same token supplied in one protocol and
+    // borrowed in another must stay as two rows (different
+    // `exposurePerCategory` buckets), and the same token supplied in two
+    // protocols must stay as two rows (allocations are reported per protocol).
+    // Repeat sightings of the same symbol/type/protocol triple accumulate.
+    //
+    // The lookup key must be the exact expression stored on the row below
+    // (`optimized_symbol` first), otherwise a token whose optimized symbol differs
+    // from its raw symbol never finds its own row and is emitted again.
+    const rowSymbol = token?.optimized_symbol || token?.symbol;
+    const foundTokenExposure = tokenExposure.find((t) => t.symbol === rowSymbol &&
+        t.exposureType === exposureType &&
+        t.protocol === protocol);
+    if (foundTokenExposure) {
+        foundTokenExposure.amount += usdAmount;
+    }
+    else {
+        const protoReturnObj = {
+            id: token?.id,
+            chain: token?.chain,
+            name: token?.name,
+            symbol: rowSymbol,
+            decimals: token?.decimals,
+            logoUrl: token?.logo_url,
+            amount: usdAmount,
+            protocol: protocol,
+            exposureType: exposureType,
+            poolId: poolId,
+        };
+        if (exposureType === 'wallet') {
+            exposurePerCategory.wallet.push(protoReturnObj);
+        }
+        else if (exposureType === 'borrow') {
+            exposurePerCategory.borrowing.push(protoReturnObj);
+        }
+        else if (exposureType === 'supply') {
+            exposurePerCategory.supplying.push(protoReturnObj);
+        }
+        tokenExposure.push(protoReturnObj);
+    }
+}
+function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borrower, exposurePerCategory, netValue) {
+    // new mapping to grab vault-level token and protocol exposure per
+    const tokenMap = {};
+    const protocolTokenMap = {};
+    const protocolExposures = debankRes?.subaccount?.positions || [];
+    const appProtocolExposures = debankRes?.subaccount?.app_positions || [];
+    const tokenExposures = debankRes?.subaccount?.tokens || [];
+    protocolExposures.forEach((pos) => {
+        // protocol-level data fetching
+        const protoReturnObj = {
+            id: pos?.id,
+            chain: pos?.chain,
+            protocol: pos?.name,
+            logoUrl: pos?.logo_url,
+            siteUrl: pos?.site_url,
+            assetUsdValue: 0,
+            debtUsdValue: 0,
+            netUsdValue: 0,
+            label: pos?.portfolio_item_list?.[0]?.name,
+            tokenExposure: tokenMap,
+            protocolExposure: protocolTokenMap,
+            address: borrower,
+        };
+        pos?.portfolio_item_list?.forEach((item) => {
+            // initialize protocol exposure
+            protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
+            protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
+            protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
+        });
+        const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
+        if (!foundExistingProtocolExposure &&
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            protocolExposure.push(protoReturnObj);
+        }
+        else if (foundExistingProtocolExposure) {
+            foundExistingProtocolExposure.netUsdValue += protoReturnObj.netUsdValue;
+            foundExistingProtocolExposure.debtUsdValue += protoReturnObj.debtUsdValue;
+            foundExistingProtocolExposure.assetUsdValue +=
+                protoReturnObj.assetUsdValue;
+        }
+        // go through the debank portfolio
+        pos.portfolio_item_list.forEach((item) => {
+            item.detail.supply_token_list.forEach((sup) => {
+                // add protocol id for vault-level "protocol exposure"
+                if (sup?.protocol_id) {
+                    const existingArray = protocolTokenMap[sup.protocol_id] || [];
+                    if (!existingArray.includes(sup.symbol))
+                        existingArray.push(sup.symbol);
+                }
+                // add token to vault "token exposure"
+                addToTokenExposure(sup, tokenExposure, 'supply', pos.id, exposurePerCategory, netValue, borrower, item?.pool?.id);
+                // add token image url to token mapping for display
+                if (sup?.symbol && sup?.logo_url) {
+                    tokenMap[sup.symbol] = sup.logo_url;
+                }
+                // `supplying_exposure` is not a DeBank token field (always undefined
+                // at runtime); kept as-is to preserve existing `tokenMap` output.
+                tokenMap[sup.supplying_exposure] =
+                    'true';
+            });
+            item.detail.borrow_token_list.forEach((bor) => {
+                // add token to vault "token exposure"
+                addToTokenExposure(bor, tokenExposure, 'borrow', pos.id, exposurePerCategory, netValue, borrower, item?.pool?.id);
+                // add token image url to token mapping for display
+                if (bor?.symbol && bor?.logo_url) {
+                    tokenMap[bor.symbol] = bor.logo_url;
+                }
+                // `supplying_exposure` is not a DeBank token field (always undefined
+                // at runtime); kept as-is to preserve existing `tokenMap` output.
+                tokenMap[bor.supplying_exposure] =
+                    'true';
+            });
+        });
+    });
+    // Process non-EVM app protocols (e.g. Hyperliquid, Lighter).
+    // These lack chain and protocol_id fields unlike EVM-based positions.
+    appProtocolExposures.forEach((pos) => {
+        const protoReturnObj = {
+            id: pos?.id,
+            chain: null,
+            protocol: pos?.name,
+            logoUrl: pos?.logo_url,
+            siteUrl: pos?.site_url,
+            assetUsdValue: 0,
+            debtUsdValue: 0,
+            netUsdValue: 0,
+            label: pos?.portfolio_item_list?.[0]?.name,
+            tokenExposure: tokenMap,
+            protocolExposure: protocolTokenMap,
+            address: borrower,
+        };
+        pos?.portfolio_item_list?.forEach((item) => {
+            protoReturnObj.assetUsdValue += item?.stats?.asset_usd_value || 0;
+            protoReturnObj.debtUsdValue += item?.stats?.debt_usd_value || 0;
+            protoReturnObj.netUsdValue += item?.stats?.net_usd_value || 0;
+        });
+        const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
+        if (!foundExistingProtocolExposure &&
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            protocolExposure.push(protoReturnObj);
+        }
+        else if (foundExistingProtocolExposure) {
+            foundExistingProtocolExposure.netUsdValue += protoReturnObj.netUsdValue;
+            foundExistingProtocolExposure.debtUsdValue += protoReturnObj.debtUsdValue;
+            foundExistingProtocolExposure.assetUsdValue +=
+                protoReturnObj.assetUsdValue;
+        }
+        pos?.portfolio_item_list?.forEach((item) => {
+            (item?.detail?.supply_token_list || []).forEach((sup) => {
+                addToTokenExposure(sup, tokenExposure, 'supply', pos.id, exposurePerCategory, netValue, borrower, 
+                // App portfolio items carry `pool` only as an untyped extra field.
+                item?.pool?.id);
+                if (sup?.symbol && sup?.logo_url) {
+                    tokenMap[sup.symbol] = sup.logo_url;
+                }
+            });
+            (item?.detail?.borrow_token_list || []).forEach((bor) => {
+                addToTokenExposure(bor, tokenExposure, 'borrow', pos.id, exposurePerCategory, netValue, borrower, 
+                // App portfolio items carry `pool` only as an untyped extra field.
+                item?.pool?.id);
+                if (bor?.symbol && bor?.logo_url) {
+                    tokenMap[bor.symbol] = bor.logo_url;
+                }
+            });
+        });
+    });
+    tokenExposures?.forEach((token) => {
+        if (token?.is_wallet) {
+            addToTokenExposure(token, tokenExposure, 'wallet', null, exposurePerCategory, netValue, borrower);
+        }
+    });
+    const loanLevelExposure = parseLoanLevelDebank(debankRes);
+    return {
+        tokenMap,
+        protocolTokenMap,
+        protocolExposures,
+        tokenExposures,
+        loansExposure: loanLevelExposure,
+    };
+}
+function getVaultExposure(debankResponse) {
+    const borrowing_exposure = [];
+    const supplying_exposure = [];
+    const wallet_exposure = [];
+    const positions = debankResponse?.subaccount?.positions ?? [];
+    const tokens = debankResponse?.subaccount?.tokens ?? [];
+    // Wallet (idle) tokens belong to the subaccount, not to any position, so
+    // they are counted exactly once — not once per portfolio item.
+    for (const token of tokens) {
+        if (token?.symbol && token?.is_core) {
+            wallet_exposure.push({
+                symbol: token.symbol,
+                chain: token.chain,
+                amount: token.amount * token.price,
+            });
+        }
+    }
+    for (const position of positions) {
+        const portfolioItems = position?.portfolio_item_list ?? [];
+        for (const item of portfolioItems) {
+            const borrowTokens = item?.detail?.borrow_token_list ?? [];
+            const supplyTokens = item?.detail?.supply_token_list ?? [];
+            for (const token of borrowTokens) {
+                if (token?.symbol &&
+                    !token.is_suspicious &&
+                    !token.is_scam &&
+                    token?.is_core) {
+                    borrowing_exposure.push({
+                        symbol: token.symbol,
+                        chain: token.chain,
+                        amount: token.amount * token.price,
+                    });
+                }
+            }
+            for (const token of supplyTokens) {
+                if (token?.symbol &&
+                    !token.is_suspicious &&
+                    !token.is_scam &&
+                    token?.is_core) {
+                    // Not sure what isWallet is, but I'm guessing is that this field means that it should be in wallet exposure...
+                    // fwiw I have seen this double counted in supplyTokens AND tokens
+                    if (!token.is_wallet) {
+                        supplying_exposure.push({
+                            symbol: token.symbol,
+                            chain: token.chain,
+                            amount: token.amount * token.price,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return { borrowing_exposure, supplying_exposure, wallet_exposure };
+}
+function parseLoanLevelDebank(debankRes) {
+    let positions = [];
+    let exposure = [];
+    try {
+        // new mapping to grab token and protocol exposure
+        const protocolExposures = [
+            ...(debankRes?.subaccount?.positions || []),
+            ...(debankRes?.subaccount?.app_positions || []),
+        ];
+        // Old mapping to grab token and protocol exposure
+        positions = protocolExposures?.map((p) => ({
+            value: p.logo_url,
+            label: p.name,
+        }));
+        exposure = protocolExposures?.map((p) => p.portfolio_item_list?.map((li) => {
+            const extra = {
+                value: li.pool?.controller,
+                label: li.pool?.adapter_id,
+                usd: li?.stats?.asset_usd_value,
+            };
+            if (li.detail?.supply_token_list?.length) {
+                const returnArr = li.detail?.supply_token_list?.map((t) => ({
+                    value: t?.id,
+                    label: t?.symbol,
+                    usd: t?.amount * t?.price,
+                }));
+                return [...returnArr, extra];
+            }
+            return extra;
+        }));
+        // this is a request where if there is no protocol exposure then show any spots
+        // over 10k in collateral exposure
+        if (protocolExposures.length === 0) {
+            if (debankRes?.subaccount?.tokens) {
+                debankRes.subaccount.tokens.forEach((t) => {
+                    if (t?.amount && t?.price && t.amount * t.price >= 10_000) {
+                        exposure.push({
+                            value: t?.id,
+                            label: t?.symbol,
+                            usd: t?.amount && t?.price ? t.amount * t.price : '',
+                        });
+                    }
+                });
+            }
+        }
+        exposure = exposure?.flat()?.flat();
+        // De-duplicate by `value` (token id / pool controller), summing `usd`
+        // across sightings. The accumulator row starts at `usd: 0` so the `+=`
+        // below counts the first sighting exactly once — seeding it with `a.usd`
+        // and then adding `a.usd` again doubled every unique exposure.
+        const uniqueExposure = [];
+        exposure?.forEach(function (a) {
+            if (!this[a.value]) {
+                if (a?.value === '0xa1290d69c65a6fe4df752f95823fae25cb99e5a7') {
+                    this[a.value] = { ...a, label: 'rsETH', usd: 0 };
+                }
+                else {
+                    this[a.value] = { ...a, usd: 0 };
+                }
+                uniqueExposure.push(this[a.value]);
+            }
+            this[a.value].usd += a.usd;
+        }, Object.create(null));
+        exposure = uniqueExposure;
+    }
+    catch (err) {
+        core_1.Logger.log.error('getPoolLoansData.strategies', err);
+    }
+    return { exposure, positions };
+}
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,55 @@
+/**
+ * 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;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
+        spokeChains: Record<number, IAddress>;
+        subgraphEndpoints: string[];
+    };
+    upUSDC: {
+        address: IAddress;
+        receiptToken: "upusdc";
+        decimals: number;
+        hubChainId: number;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
+        spokeChains: Record<number, IAddress>;
+        subgraphEndpoints: string[];
+    };
+    earnAUSD: {
+        address: IAddress;
+        receiptToken: "earnausd";
+        decimals: number;
+        hubChainId: number;
+        hubComposer: IAddress;
+        hubShareOFT: IAddress;
+        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,174 @@
+"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)
+// hubComposer / hubShareOFT: the hub-chain OVault composer (VAULT() is the
+// vault) and its SHARE_OFT(), verified on-chain 2026-10-01
+exports.LAYERZERO_VAULTS = {
+    coreUSDC: {
+        address: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32',
+        receiptToken: 'coreusdc',
+        decimals: 6, // USDC decimals
+        hubChainId: 1,
+        hubComposer: '0xc2637d7721791cc9cb196628d1e5e06887b1d4b9',
+        hubShareOFT: '0x4A21dcbA38c3816C78144f33bb42D8fa17F38067',
+        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,
+        hubComposer: '0xbe82134b95a8e9370e6759f3c8f44087cd9a52be',
+        hubShareOFT: '0x81971A3C359cFE74259CfF1b46FB5f2112ddDE34',
+        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,
+        hubComposer: '0xd1b1b12533e12badb8ea6d63aedd11922cae5580',
+        hubShareOFT: '0x9549Fa3DF579Cca9F3e328695382675F7f1f0F34',
+        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;