@eulerxyz/euler-v2-sdk 0.1.0-beta

package/dist/src/services/vaults/eVaultService/adapters/eVaultV3Adapter/eVaultV3AdapterConversions.js

@@ -0,0 +1,795 @@
+import { getAddress } from "viem";
+import { sortOracleResolvedVaults } from "../../../../../utils/oracle.js";
+import { parseAddressField, parseBigIntField, parseBooleanField, parseNumberField, parseRatio1e4, parseStringField, parseTimestampField, ZERO_ADDRESS, } from "../../../../../utils/parsing.js";
+import { hasActiveBorrowableLtv, } from "../../../../../entities/EVault.js";
+import { VaultType } from "../../../../../utils/types.js";
+import { InterestRateModelType } from "../eVaultOnchainAdapter/eVaultLensTypes.js";
+import { normalizeIRMParams, decorateIRMParams, } from "../../../../../utils/irm.js";
+const DEFAULT_HOOKED_OPERATIONS = {
+    deposit: false,
+    mint: false,
+    withdraw: false,
+    redeem: false,
+    transfer: false,
+    skim: false,
+    borrow: false,
+    repay: false,
+    repayWithShares: false,
+    pullDebt: false,
+    convertFees: false,
+    liquidate: false,
+    flashloan: false,
+    touch: false,
+    vaultStatusCheck: false,
+};
+const DEFAULT_TOKEN_BLOCK = {
+    address: ZERO_ADDRESS,
+    symbol: "",
+    decimals: 0,
+    name: "",
+};
+const DEFAULT_ORACLE_BLOCK = {
+    oracle: ZERO_ADDRESS,
+    name: "",
+    adapters: [],
+};
+const DEFAULT_CAPS_BLOCK = {
+    supplyCap: "0",
+    borrowCap: "0",
+};
+const DEFAULT_LIQUIDATION_BLOCK = {
+    maxLiquidationDiscount: 0,
+    liquidationCoolOffTime: 0,
+    socializeDebt: false,
+};
+const DEFAULT_INTEREST_RATES_BLOCK = {
+    borrowSPY: "0",
+    borrowAPY: "0",
+    supplyAPY: "0",
+};
+const DEFAULT_INTEREST_RATE_MODEL_BLOCK = {
+    address: ZERO_ADDRESS,
+    type: "unknown",
+    data: null,
+};
+const DEFAULT_ORACLE_PRICE_BLOCK = {
+    queryFailure: true,
+    queryFailureReason: "0x",
+    amountIn: "0",
+    amountOutMid: "0",
+    amountOutBid: "0",
+    amountOutAsk: "0",
+    timestamp: "",
+};
+function normalizeUnitOfAccountToken(token) {
+    if (token.address.toLowerCase() === ZERO_ADDRESS.toLowerCase()) {
+        return undefined;
+    }
+    return {
+        ...token,
+        decimals: token.decimals > 0 ? token.decimals : 18,
+    };
+}
+function mapInterestRateModelType(type) {
+    switch (type.toLowerCase()) {
+        case "kink":
+            return InterestRateModelType.KINK;
+        case "adaptive_curve":
+        case "adaptive-curve":
+            return InterestRateModelType.ADAPTIVE_CURVE;
+        case "kinky":
+            return InterestRateModelType.KINKY;
+        case "fixed_cyclical_binary":
+        case "fixed-cyclical-binary":
+            return InterestRateModelType.FIXED_CYCLICAL_BINARY;
+        default:
+            return InterestRateModelType.UNKNOWN;
+    }
+}
+function convertToken(token, path, entityId, errors) {
+    return {
+        address: parseAddressField(token.address, {
+            path: `${path}.address`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        name: parseStringField(token.name, {
+            path: `${path}.name`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        symbol: parseStringField(token.symbol, {
+            path: `${path}.symbol`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        decimals: parseNumberField(token.decimals, {
+            path: `${path}.decimals`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+    };
+}
+function convertOraclePrice(price, errors, path, entityId) {
+    const converted = {
+        queryFailure: parseBooleanField(price.queryFailure, {
+            path: `${path}.queryFailure`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+            fallback: true,
+        }),
+        queryFailureReason: parseStringField(price.queryFailureReason, {
+            path: `${path}.queryFailureReason`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+            fallback: "0x",
+        }),
+        amountIn: parseBigIntField(price.amountIn, {
+            path: `${path}.amountIn`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        amountOutMid: parseBigIntField(price.amountOutMid, {
+            path: `${path}.amountOutMid`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        amountOutBid: parseBigIntField(price.amountOutBid, {
+            path: `${path}.amountOutBid`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        amountOutAsk: parseBigIntField(price.amountOutAsk, {
+            path: `${path}.amountOutAsk`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        timestamp: parseTimestampField(price.timestamp, {
+            path: `${path}.timestamp`,
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+    };
+    if (converted.queryFailure) {
+        errors.push({
+            code: "SOURCE_UNAVAILABLE",
+            severity: "warning",
+            message: "Oracle price query reported failure.",
+            paths: [path],
+            entityId,
+            source: "eVaultV3",
+            originalValue: converted.queryFailureReason,
+            normalizedValue: "queryFailure:true",
+        });
+    }
+    return converted;
+}
+function convertOracleAdapter(adapter, entityId, errors) {
+    const converted = {
+        oracle: parseAddressField(adapter.oracle, {
+            path: "$.oracle.adapters[].oracle",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        name: parseStringField(adapter.name, {
+            path: "$.oracle.adapters[].name",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        base: parseAddressField(adapter.base, {
+            path: "$.oracle.adapters[].base",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        quote: parseAddressField(adapter.quote, {
+            path: "$.oracle.adapters[].quote",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+    };
+    if (adapter.pythDetail) {
+        converted.pythDetail = {
+            pyth: parseAddressField(adapter.pythDetail.pyth, {
+                path: "$.oracle.adapters[].pythDetail.pyth",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+            base: parseAddressField(adapter.pythDetail.base, {
+                path: "$.oracle.adapters[].pythDetail.base",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+            quote: parseAddressField(adapter.pythDetail.quote, {
+                path: "$.oracle.adapters[].pythDetail.quote",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+            feedId: parseStringField(adapter.pythDetail.feedId, {
+                path: "$.oracle.adapters[].pythDetail.feedId",
+                entityId,
+                errors,
+                source: "eVaultV3",
+                fallback: "0x",
+            }),
+            maxStaleness: parseBigIntField(String(adapter.pythDetail.maxStaleness), {
+                path: "$.oracle.adapters[].pythDetail.maxStaleness",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+            maxConfWidth: parseBigIntField(String(adapter.pythDetail.maxConfWidth), {
+                path: "$.oracle.adapters[].pythDetail.maxConfWidth",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+        };
+    }
+    if (adapter.chainlinkDetail) {
+        converted.chainlinkDetail = {
+            oracle: parseAddressField(adapter.chainlinkDetail.oracle, {
+                path: "$.oracle.adapters[].chainlinkDetail.oracle",
+                entityId,
+                errors,
+                source: "eVaultV3",
+            }),
+        };
+    }
+    return converted;
+}
+function convertCollaterals(rows, vaultTimestamp, vaultEntityId, errors) {
+    const collaterals = [];
+    for (const [index, row] of rows.entries()) {
+        const collateralAddress = parseAddressField(row.collateral, {
+            path: `$.collaterals[${index}].collateral`,
+            entityId: vaultEntityId,
+            errors,
+            source: "eVaultV3",
+        });
+        const borrowLTV = parseRatio1e4(row.borrowLTV, {
+            path: `$.collaterals[${index}].borrowLTV`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const liquidationLTV = parseRatio1e4(row.liquidationLTV, {
+            path: `$.collaterals[${index}].liquidationLTV`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const targetTimestamp = parseNumberField(typeof row.targetTimestamp === "number"
+            ? row.targetTimestamp
+            : Number(row.targetTimestamp), {
+            path: `$.collaterals[${index}].targetTimestamp`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const isRemovedCollateral = borrowLTV === 0 &&
+            liquidationLTV === 0 &&
+            targetTimestamp < vaultTimestamp;
+        if (isRemovedCollateral)
+            continue;
+        const collateral = {
+            address: collateralAddress,
+            borrowLTV,
+            liquidationLTV,
+            oraclePriceRaw: row.oraclePriceRaw
+                ? convertOraclePrice(row.oraclePriceRaw, errors, `$.collaterals[${collaterals.length}].oraclePriceRaw`, collateralAddress)
+                : {
+                    queryFailure: true,
+                    queryFailureReason: "0x",
+                    amountIn: 0n,
+                    amountOutMid: 0n,
+                    amountOutBid: 0n,
+                    amountOutAsk: 0n,
+                    timestamp: 0,
+                },
+        };
+        if (!row.oraclePriceRaw) {
+            errors.push({
+                code: "DEFAULT_APPLIED",
+                severity: "warning",
+                message: "Missing collateral oraclePriceRaw; default zero-price placeholder applied.",
+                paths: [`$.collaterals[${collaterals.length}].oraclePriceRaw`],
+                entityId: collateralAddress,
+                source: "eVaultV3",
+                normalizedValue: "queryFailure:true",
+            });
+        }
+        if (targetTimestamp > vaultTimestamp) {
+            const ramping = {
+                initialLiquidationLTV: parseRatio1e4(row.initialLiquidationLTV, {
+                    path: `$.collaterals[${collaterals.length}].ramping.initialLiquidationLTV`,
+                    entityId: collateralAddress,
+                    errors,
+                    source: "eVaultV3",
+                }),
+                targetTimestamp,
+                rampDuration: parseBigIntField(String(row.rampDuration ?? 0), {
+                    path: `$.collaterals[${collaterals.length}].ramping.rampDuration`,
+                    entityId: collateralAddress,
+                    errors,
+                    source: "eVaultV3",
+                }),
+            };
+            collateral.ramping = ramping;
+        }
+        collaterals.push(collateral);
+    }
+    return collaterals;
+}
+function convertResolvedVaults(rows, vaultTimestamp, quoteAddress, vaultEntityId, errors) {
+    if (!quoteAddress)
+        return [];
+    const resolvedVaults = [];
+    for (const [index, row] of rows.entries()) {
+        if (!row.asset)
+            continue;
+        const collateralAddress = parseAddressField(row.collateral, {
+            path: `$.collaterals[${index}].collateral`,
+            entityId: vaultEntityId,
+            errors,
+            source: "eVaultV3",
+        });
+        const assetAddress = parseAddressField(row.asset, {
+            path: `$.collaterals[${index}].asset`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const borrowLTV = parseRatio1e4(row.borrowLTV, {
+            path: `$.collaterals[${index}].borrowLTV`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const liquidationLTV = parseRatio1e4(row.liquidationLTV, {
+            path: `$.collaterals[${index}].liquidationLTV`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const targetTimestamp = parseNumberField(typeof row.targetTimestamp === "number"
+            ? row.targetTimestamp
+            : Number(row.targetTimestamp), {
+            path: `$.collaterals[${index}].targetTimestamp`,
+            entityId: collateralAddress,
+            errors,
+            source: "eVaultV3",
+        });
+        const isRemovedCollateral = borrowLTV === 0 &&
+            liquidationLTV === 0 &&
+            targetTimestamp < vaultTimestamp;
+        if (isRemovedCollateral)
+            continue;
+        if (assetAddress.toLowerCase() === collateralAddress.toLowerCase())
+            continue;
+        resolvedVaults.push({
+            vault: collateralAddress,
+            asset: assetAddress,
+            quote: quoteAddress,
+            resolvedAssets: [assetAddress],
+        });
+    }
+    return sortOracleResolvedVaults(resolvedVaults);
+}
+export function convertVault(detail, collateralRows, errors, fallbackAddress) {
+    const hasZeroOracleAddress = detail.oracle?.oracle !== undefined &&
+        (() => {
+            try {
+                return getAddress(detail.oracle.oracle) === ZERO_ADDRESS;
+            }
+            catch {
+                return false;
+            }
+        })();
+    const entityId = parseAddressField(detail.address, {
+        path: "$.address",
+        entityId: fallbackAddress,
+        errors,
+        source: "eVaultV3",
+        fallback: fallbackAddress,
+        fallbackLabel: "requested vault address",
+    });
+    if (!detail.oracle) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing oracle block; defaulted all oracle fields to 0/empty.",
+            paths: ["$.oracle"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_ORACLE_BLOCK,
+        });
+    }
+    const oracleData = detail.oracle ?? DEFAULT_ORACLE_BLOCK;
+    const oracle = {
+        oracle: parseAddressField(oracleData.oracle, {
+            path: "$.oracle.oracle",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        name: parseStringField(oracleData.name, {
+            path: "$.oracle.name",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        adapters: oracleData.adapters.map((adapter) => convertOracleAdapter(adapter, entityId, errors)),
+        resolvedVaults: [],
+    };
+    const suppressUnitOfAccountDiagnostics = hasZeroOracleAddress;
+    if (!detail.shares) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing shares block; defaulted all share token fields to 0/empty.",
+            paths: ["$.shares"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_TOKEN_BLOCK,
+        });
+    }
+    const sharesData = detail.shares ?? DEFAULT_TOKEN_BLOCK;
+    if (!detail.asset) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing asset block; defaulted all asset token fields to 0/empty.",
+            paths: ["$.asset"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_TOKEN_BLOCK,
+        });
+    }
+    const assetData = detail.asset ?? DEFAULT_TOKEN_BLOCK;
+    if (!detail.unitOfAccount && !suppressUnitOfAccountDiagnostics) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing unitOfAccount block; defaulted all unit-of-account fields to 0/empty.",
+            paths: ["$.unitOfAccount"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_TOKEN_BLOCK,
+        });
+    }
+    const unitOfAccountData = detail.unitOfAccount ?? DEFAULT_TOKEN_BLOCK;
+    const unitOfAccountErrors = suppressUnitOfAccountDiagnostics ? [] : errors;
+    if (!detail.fees) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing fees object; defaulted all fee fields to 0.",
+            paths: ["$.fees"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: {
+                interestFee: 0,
+                accumulatedFeesShares: "0",
+                accumulatedFeesAssets: "0",
+                governorFeeReceiver: ZERO_ADDRESS,
+                protocolFeeReceiver: ZERO_ADDRESS,
+                protocolFeeShare: 0,
+            },
+        });
+    }
+    const feeData = detail.fees ?? {
+        interestFee: 0,
+        accumulatedFeesShares: "0",
+        accumulatedFeesAssets: "0",
+        governorFeeReceiver: ZERO_ADDRESS,
+        protocolFeeReceiver: ZERO_ADDRESS,
+        protocolFeeShare: 0,
+    };
+    const fees = {
+        interestFee: feeData.interestFee ?? 0,
+        accumulatedFeesShares: parseBigIntField(feeData.accumulatedFeesShares ?? "0", {
+            path: "$.fees.accumulatedFeesShares",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        accumulatedFeesAssets: parseBigIntField(feeData.accumulatedFeesAssets ?? "0", {
+            path: "$.fees.accumulatedFeesAssets",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        governorFeeReceiver: parseAddressField(feeData.governorFeeReceiver, {
+            path: "$.fees.governorFeeReceiver",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        protocolFeeReceiver: parseAddressField(feeData.protocolFeeReceiver, {
+            path: "$.fees.protocolFeeReceiver",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        protocolFeeShare: feeData.protocolFeeShare ?? 0,
+    };
+    const hooks = {
+        hookedOperations: {
+            ...DEFAULT_HOOKED_OPERATIONS,
+            ...(detail.hooks?.hookedOperations ?? {}),
+        },
+        hookTarget: parseAddressField(detail.hooks?.hookTarget, {
+            path: "$.hooks.hookTarget",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+    };
+    if (!detail.hooks?.hookedOperations) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing hookedOperations; defaulted all operations to false.",
+            paths: ["$.hooks.hookedOperations"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_HOOKED_OPERATIONS,
+        });
+    }
+    if (!detail.caps) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing caps block; defaulted all cap fields to 0.",
+            paths: ["$.caps"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_CAPS_BLOCK,
+        });
+    }
+    const capsData = detail.caps ?? DEFAULT_CAPS_BLOCK;
+    const caps = {
+        supplyCap: parseBigIntField(capsData.supplyCap ?? "0", {
+            path: "$.caps.supplyCap",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        borrowCap: parseBigIntField(capsData.borrowCap ?? "0", {
+            path: "$.caps.borrowCap",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+    };
+    if (!detail.liquidation) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing liquidation block; defaulted all liquidation fields to 0/false.",
+            paths: ["$.liquidation"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: {
+                maxLiquidationDiscount: 0,
+                liquidationCoolOffTime: 0,
+                socializeDebt: false,
+            },
+        });
+    }
+    const liquidationData = detail.liquidation ?? DEFAULT_LIQUIDATION_BLOCK;
+    const liquidation = {
+        maxLiquidationDiscount: liquidationData.maxLiquidationDiscount ?? 0,
+        liquidationCoolOffTime: liquidationData.liquidationCoolOffTime ?? 0,
+        socializeDebt: liquidationData.socializeDebt ?? false,
+    };
+    if (!detail.interestRates) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing interestRates block; defaulted all rate fields to 0.",
+            paths: ["$.interestRates"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_INTEREST_RATES_BLOCK,
+        });
+    }
+    const interestRatesData = detail.interestRates ?? DEFAULT_INTEREST_RATES_BLOCK;
+    const interestRates = {
+        borrowSPY: parseStringField(interestRatesData.borrowSPY, {
+            path: "$.interestRates.borrowSPY",
+            entityId,
+            errors,
+            source: "eVaultV3",
+            fallback: "0",
+        }),
+        borrowAPY: parseStringField(interestRatesData.borrowAPY, {
+            path: "$.interestRates.borrowAPY",
+            entityId,
+            errors,
+            source: "eVaultV3",
+            fallback: "0",
+        }),
+        supplyAPY: parseStringField(interestRatesData.supplyAPY, {
+            path: "$.interestRates.supplyAPY",
+            entityId,
+            errors,
+            source: "eVaultV3",
+            fallback: "0",
+        }),
+    };
+    if (!detail.interestRateModel) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing interestRateModel block; defaulted all model fields to 0/unknown.",
+            paths: ["$.interestRateModel"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_INTEREST_RATE_MODEL_BLOCK,
+        });
+    }
+    const interestRateModelData = detail.interestRateModel ?? DEFAULT_INTEREST_RATE_MODEL_BLOCK;
+    const interestRateModelType = mapInterestRateModelType(parseStringField(interestRateModelData.type, {
+        path: "$.interestRateModel.type",
+        entityId,
+        errors,
+        source: "eVaultV3",
+        fallback: "unknown",
+    }));
+    const normalizedIRMData = normalizeIRMParams(interestRateModelType, interestRateModelData.data);
+    const interestRateModelAddress = parseAddressField(interestRateModelData.address, {
+        path: "$.interestRateModel.address",
+        entityId,
+        errors,
+        source: "eVaultV3",
+    });
+    const interestRateModel = interestRateModelType === InterestRateModelType.KINK
+        ? {
+            address: interestRateModelAddress,
+            type: InterestRateModelType.KINK,
+            data: normalizedIRMData,
+            params: decorateIRMParams(interestRateModelType, normalizedIRMData, fees.interestFee),
+        }
+        : interestRateModelType === InterestRateModelType.ADAPTIVE_CURVE
+            ? {
+                address: interestRateModelAddress,
+                type: InterestRateModelType.ADAPTIVE_CURVE,
+                data: normalizedIRMData,
+                params: decorateIRMParams(interestRateModelType, normalizedIRMData, fees.interestFee),
+            }
+            : interestRateModelType === InterestRateModelType.KINKY
+                ? {
+                    address: interestRateModelAddress,
+                    type: InterestRateModelType.KINKY,
+                    data: normalizedIRMData,
+                    params: decorateIRMParams(interestRateModelType, normalizedIRMData, fees.interestFee),
+                }
+                : interestRateModelType ===
+                    InterestRateModelType.FIXED_CYCLICAL_BINARY
+                    ? {
+                        address: interestRateModelAddress,
+                        type: InterestRateModelType.FIXED_CYCLICAL_BINARY,
+                        data: normalizedIRMData,
+                        params: decorateIRMParams(interestRateModelType, normalizedIRMData, fees.interestFee),
+                    }
+                    : {
+                        address: interestRateModelAddress,
+                        type: InterestRateModelType.UNKNOWN,
+                        data: null,
+                        params: null,
+                    };
+    if (!detail.oraclePriceRaw) {
+        errors.push({
+            code: "DEFAULT_APPLIED",
+            severity: "warning",
+            message: "Missing oraclePriceRaw block; defaulted all oracle price fields to 0.",
+            paths: ["$.oraclePriceRaw"],
+            entityId,
+            source: "eVaultV3",
+            normalizedValue: DEFAULT_ORACLE_PRICE_BLOCK,
+        });
+    }
+    const oraclePriceData = detail.oraclePriceRaw ?? DEFAULT_ORACLE_PRICE_BLOCK;
+    const timestamp = parseTimestampField(detail.timestamp, {
+        path: "$.timestamp",
+        entityId,
+        errors,
+        source: "eVaultV3",
+    });
+    const collaterals = convertCollaterals(collateralRows, timestamp, entityId, errors);
+    const unitOfAccount = normalizeUnitOfAccountToken(convertToken(unitOfAccountData, "$.unitOfAccount", entityId, unitOfAccountErrors));
+    oracle.resolvedVaults = convertResolvedVaults(oracle.name === "EulerRouter" ? collateralRows : [], timestamp, unitOfAccount?.address, entityId, errors);
+    return {
+        type: VaultType.EVault,
+        chainId: detail.chainId,
+        address: entityId,
+        shares: convertToken(sharesData, "$.shares", entityId, errors),
+        asset: convertToken(assetData, "$.asset", entityId, errors),
+        unitOfAccount,
+        totalShares: parseBigIntField(detail.totalShares, {
+            path: "$.totalShares",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        totalAssets: parseBigIntField(detail.totalAssets, {
+            path: "$.totalAssets",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        totalCash: parseBigIntField(detail.totalCash, {
+            path: "$.totalCash",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        totalBorrowed: parseBigIntField(detail.totalBorrowed, {
+            path: "$.totalBorrowed",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        creator: parseAddressField(detail.creator, {
+            path: "$.creator",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        governorAdmin: parseAddressField(detail.governorAdmin, {
+            path: "$.governorAdmin",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        dToken: parseAddressField(detail.dToken, {
+            path: "$.dToken",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        balanceTracker: parseAddressField(detail.balanceTracker, {
+            path: "$.balanceTracker",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        fees,
+        hooks,
+        caps,
+        liquidation,
+        oracle,
+        interestRates,
+        interestRateModel,
+        collaterals,
+        isBorrowable: hasActiveBorrowableLtv(collaterals, timestamp),
+        evcCompatibleAsset: parseBooleanField(detail.evcCompatibleAsset, {
+            path: "$.evcCompatibleAsset",
+            entityId,
+            errors,
+            source: "eVaultV3",
+        }),
+        oraclePriceRaw: convertOraclePrice(oraclePriceData, errors, "$.oraclePriceRaw", entityId),
+        timestamp,
+    };
+}
+//# sourceMappingURL=eVaultV3AdapterConversions.js.map