@elizaos/plugin-aave 1.0.0

package/dist/index.js

@@ -0,0 +1,2923 @@
+import { Service, elizaLogger, ModelType } from '@elizaos/core';
+import { Pool, UiPoolDataProvider } from '@aave/contract-helpers';
+import { formatReserves, formatUserSummary } from '@aave/math-utils';
+import { ethers } from 'ethers';
+import BigNumber3, { BigNumber } from 'bignumber.js';
+import { AaveV3BaseSepolia, AaveV3OptimismSepolia, AaveV3ArbitrumSepolia, AaveV3Fuji, AaveV3Sepolia, AaveV3ZkSync, AaveV3Scroll, AaveV3Metis, AaveV3Gnosis, AaveV3BNB, AaveV3Base, AaveV3Optimism, AaveV3Arbitrum, AaveV3Avalanche, AaveV3Polygon, AaveV3Ethereum } from '@bgd-labs/aave-address-book';
+
+// src/services/aave-service.ts
+
+// src/types/chains.ts
+var SupportedChain = /* @__PURE__ */ ((SupportedChain2) => {
+  SupportedChain2["ETHEREUM"] = "ethereum";
+  SupportedChain2["POLYGON"] = "polygon";
+  SupportedChain2["AVALANCHE"] = "avalanche";
+  SupportedChain2["ARBITRUM"] = "arbitrum";
+  SupportedChain2["OPTIMISM"] = "optimism";
+  SupportedChain2["BASE"] = "base";
+  SupportedChain2["BNB"] = "bnb";
+  SupportedChain2["GNOSIS"] = "gnosis";
+  SupportedChain2["METIS"] = "metis";
+  SupportedChain2["SCROLL"] = "scroll";
+  SupportedChain2["ZKSYNC"] = "zksync";
+  SupportedChain2["SEPOLIA"] = "sepolia";
+  SupportedChain2["FUJI"] = "fuji";
+  SupportedChain2["ARBITRUM_SEPOLIA"] = "arbitrum-sepolia";
+  SupportedChain2["OPTIMISM_SEPOLIA"] = "optimism-sepolia";
+  SupportedChain2["BASE_SEPOLIA"] = "base-sepolia";
+  return SupportedChain2;
+})(SupportedChain || {});
+var CHAIN_CONFIGS = {
+  ["ethereum" /* ETHEREUM */]: {
+    name: "Ethereum",
+    chainId: 1,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://eth.llamarpc.com",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "DAI", "WETH", "WBTC", "LINK", "AAVE"]
+  },
+  ["polygon" /* POLYGON */]: {
+    name: "Polygon",
+    chainId: 137,
+    nativeCurrency: "MATIC",
+    wrappedNative: "WMATIC",
+    defaultRpcUrl: "https://polygon-rpc.com",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "DAI", "WMATIC", "WETH", "WBTC", "AAVE"]
+  },
+  ["avalanche" /* AVALANCHE */]: {
+    name: "Avalanche",
+    chainId: 43114,
+    nativeCurrency: "AVAX",
+    wrappedNative: "WAVAX",
+    defaultRpcUrl: "https://api.avax.network/ext/bc/C/rpc",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "DAI.e", "WAVAX", "WETH.e", "WBTC.e", "AAVE.e"]
+  },
+  ["arbitrum" /* ARBITRUM */]: {
+    name: "Arbitrum One",
+    chainId: 42161,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://arb1.arbitrum.io/rpc",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "DAI", "WETH", "WBTC", "LINK", "ARB"]
+  },
+  ["optimism" /* OPTIMISM */]: {
+    name: "Optimism",
+    chainId: 10,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://mainnet.optimism.io",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "DAI", "WETH", "WBTC", "LINK", "OP"]
+  },
+  ["base" /* BASE */]: {
+    name: "Base",
+    chainId: 8453,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://mainnet.base.org",
+    isTestnet: false,
+    popularAssets: ["USDC", "DAI", "WETH", "cbETH", "AERO"]
+  },
+  ["bnb" /* BNB */]: {
+    name: "BNB Chain",
+    chainId: 56,
+    nativeCurrency: "BNB",
+    wrappedNative: "WBNB",
+    defaultRpcUrl: "https://bsc-dataseed1.binance.org",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "WBNB", "BTCB", "ETH", "FDUSD"]
+  },
+  ["gnosis" /* GNOSIS */]: {
+    name: "Gnosis Chain",
+    chainId: 100,
+    nativeCurrency: "xDAI",
+    wrappedNative: "WXDAI",
+    defaultRpcUrl: "https://rpc.gnosischain.com",
+    isTestnet: false,
+    popularAssets: ["USDC", "WXDAI", "WETH", "GNO"]
+  },
+  ["metis" /* METIS */]: {
+    name: "Metis",
+    chainId: 1088,
+    nativeCurrency: "METIS",
+    wrappedNative: "WMETIS",
+    defaultRpcUrl: "https://andromeda.metis.io/?owner=1088",
+    isTestnet: false,
+    popularAssets: ["m.USDC", "m.USDT", "m.DAI", "WMETIS", "METIS"]
+  },
+  ["scroll" /* SCROLL */]: {
+    name: "Scroll",
+    chainId: 534352,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://rpc.scroll.io",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "WETH", "WBTC"]
+  },
+  ["zksync" /* ZKSYNC */]: {
+    name: "zkSync Era",
+    chainId: 324,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://mainnet.era.zksync.io",
+    isTestnet: false,
+    popularAssets: ["USDC", "USDT", "WETH", "WBTC"]
+  },
+  // Testnets
+  ["sepolia" /* SEPOLIA */]: {
+    name: "Ethereum Sepolia",
+    chainId: 11155111,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://sepolia.infura.io/v3/demo",
+    isTestnet: true,
+    popularAssets: ["USDC", "USDT", "DAI", "WETH", "LINK", "AAVE"]
+  },
+  ["fuji" /* FUJI */]: {
+    name: "Avalanche Fuji",
+    chainId: 43113,
+    nativeCurrency: "AVAX",
+    wrappedNative: "WAVAX",
+    defaultRpcUrl: "https://api.avax-test.network/ext/bc/C/rpc",
+    isTestnet: true,
+    popularAssets: ["USDC", "WAVAX", "WETH.e"]
+  },
+  ["arbitrum-sepolia" /* ARBITRUM_SEPOLIA */]: {
+    name: "Arbitrum Sepolia",
+    chainId: 421614,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    isTestnet: true,
+    popularAssets: ["USDC", "WETH"]
+  },
+  ["optimism-sepolia" /* OPTIMISM_SEPOLIA */]: {
+    name: "Optimism Sepolia",
+    chainId: 11155420,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://sepolia.optimism.io",
+    isTestnet: true,
+    popularAssets: ["USDC", "WETH"]
+  },
+  ["base-sepolia" /* BASE_SEPOLIA */]: {
+    name: "Base Sepolia",
+    chainId: 84532,
+    nativeCurrency: "ETH",
+    wrappedNative: "WETH",
+    defaultRpcUrl: "https://sepolia.base.org",
+    isTestnet: true,
+    popularAssets: ["USDC", "WETH"]
+  }
+};
+var InterestRateMode = /* @__PURE__ */ ((InterestRateMode2) => {
+  InterestRateMode2[InterestRateMode2["STABLE"] = 1] = "STABLE";
+  InterestRateMode2[InterestRateMode2["VARIABLE"] = 2] = "VARIABLE";
+  return InterestRateMode2;
+})(InterestRateMode || {});
+var AaveErrorCode = /* @__PURE__ */ ((AaveErrorCode2) => {
+  AaveErrorCode2["UNKNOWN"] = "UNKNOWN";
+  AaveErrorCode2["INSUFFICIENT_BALANCE"] = "INSUFFICIENT_BALANCE";
+  AaveErrorCode2["INSUFFICIENT_COLLATERAL"] = "INSUFFICIENT_COLLATERAL";
+  AaveErrorCode2["ASSET_NOT_SUPPORTED"] = "ASSET_NOT_SUPPORTED";
+  AaveErrorCode2["BORROWING_NOT_ENABLED"] = "BORROWING_NOT_ENABLED";
+  AaveErrorCode2["STABLE_BORROWING_NOT_ENABLED"] = "STABLE_BORROWING_NOT_ENABLED";
+  AaveErrorCode2["HEALTH_FACTOR_TOO_LOW"] = "HEALTH_FACTOR_TOO_LOW";
+  AaveErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  AaveErrorCode2["INVALID_PARAMETERS"] = "INVALID_PARAMETERS";
+  AaveErrorCode2["USER_HAS_STABLE_RATE_LOAN"] = "USER_HAS_STABLE_RATE_LOAN";
+  AaveErrorCode2["AMOUNT_TOO_HIGH"] = "AMOUNT_TOO_HIGH";
+  AaveErrorCode2["POOL_PAUSED"] = "POOL_PAUSED";
+  AaveErrorCode2["RESERVE_FROZEN"] = "RESERVE_FROZEN";
+  AaveErrorCode2["RESERVE_INACTIVE"] = "RESERVE_INACTIVE";
+  AaveErrorCode2["INITIALIZATION_FAILED"] = "INITIALIZATION_FAILED";
+  AaveErrorCode2["CONNECTION_FAILED"] = "CONNECTION_FAILED";
+  AaveErrorCode2["SERVICE_NOT_INITIALIZED"] = "SERVICE_NOT_INITIALIZED";
+  AaveErrorCode2["WALLET_NOT_CONNECTED"] = "WALLET_NOT_CONNECTED";
+  AaveErrorCode2["TRANSACTION_GENERATION_FAILED"] = "TRANSACTION_GENERATION_FAILED";
+  AaveErrorCode2["SUPPLY_FAILED"] = "SUPPLY_FAILED";
+  AaveErrorCode2["WITHDRAW_FAILED"] = "WITHDRAW_FAILED";
+  AaveErrorCode2["BORROW_FAILED"] = "BORROW_FAILED";
+  AaveErrorCode2["REPAY_FAILED"] = "REPAY_FAILED";
+  AaveErrorCode2["DATA_FETCH_FAILED"] = "DATA_FETCH_FAILED";
+  AaveErrorCode2["ASSET_NOT_FOUND"] = "ASSET_NOT_FOUND";
+  AaveErrorCode2["UNSUPPORTED_ASSET"] = "UNSUPPORTED_ASSET";
+  AaveErrorCode2["NO_BORROW_CAPACITY"] = "NO_BORROW_CAPACITY";
+  AaveErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
+  return AaveErrorCode2;
+})(AaveErrorCode || {});
+var AaveError = class extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Original error that caused this error */
+  cause;
+  /** Additional context about the error */
+  context;
+  constructor(message, code = "UNKNOWN" /* UNKNOWN */, cause, context) {
+    super(message);
+    this.name = "AaveError";
+    this.code = code;
+    this.cause = cause;
+    this.context = context;
+  }
+};
+var AAVE_CONSTANTS = {
+  /** Maximum uint256 value for unlimited approvals/withdrawals */
+  MAX_UINT256: new BigNumber("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
+  /** Number of seconds in a year for APY calculations */
+  SECONDS_PER_YEAR: new BigNumber(31536e3),
+  /** Number of ray units (1e27) used by Aave for rate calculations */
+  RAY: new BigNumber("1000000000000000000000000000"),
+  /** Number of wei units (1e18) */
+  WAD: new BigNumber("1000000000000000000"),
+  /** Percentage multiplier (100 for percentage) */
+  PERCENTAGE_FACTOR: new BigNumber(1e4)
+};
+function isAaveError(error) {
+  return error instanceof AaveError;
+}
+function isValidInterestRateMode(mode) {
+  return mode === 1 /* STABLE */ || mode === 2 /* VARIABLE */;
+}
+
+// src/utils/chain-resolver.ts
+var CHAIN_ADDRESS_MAP = {
+  // Mainnets
+  ["ethereum" /* ETHEREUM */]: {
+    POOL: AaveV3Ethereum.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Ethereum.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Ethereum.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Ethereum.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Ethereum.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Ethereum.ACL_MANAGER,
+    COLLECTOR: AaveV3Ethereum.COLLECTOR,
+    ORACLE: AaveV3Ethereum.ORACLE
+  },
+  ["polygon" /* POLYGON */]: {
+    POOL: AaveV3Polygon.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Polygon.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Polygon.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Polygon.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Polygon.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Polygon.ACL_MANAGER,
+    COLLECTOR: AaveV3Polygon.COLLECTOR,
+    ORACLE: AaveV3Polygon.ORACLE
+  },
+  ["avalanche" /* AVALANCHE */]: {
+    POOL: AaveV3Avalanche.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Avalanche.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Avalanche.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Avalanche.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Avalanche.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Avalanche.ACL_MANAGER,
+    COLLECTOR: AaveV3Avalanche.COLLECTOR,
+    ORACLE: AaveV3Avalanche.ORACLE
+  },
+  ["arbitrum" /* ARBITRUM */]: {
+    POOL: AaveV3Arbitrum.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Arbitrum.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Arbitrum.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Arbitrum.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Arbitrum.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Arbitrum.ACL_MANAGER,
+    COLLECTOR: AaveV3Arbitrum.COLLECTOR,
+    ORACLE: AaveV3Arbitrum.ORACLE
+  },
+  ["optimism" /* OPTIMISM */]: {
+    POOL: AaveV3Optimism.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Optimism.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Optimism.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Optimism.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Optimism.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Optimism.ACL_MANAGER,
+    COLLECTOR: AaveV3Optimism.COLLECTOR,
+    ORACLE: AaveV3Optimism.ORACLE
+  },
+  ["base" /* BASE */]: {
+    POOL: AaveV3Base.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Base.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Base.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Base.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Base.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Base.ACL_MANAGER,
+    COLLECTOR: AaveV3Base.COLLECTOR,
+    ORACLE: AaveV3Base.ORACLE
+  },
+  ["bnb" /* BNB */]: {
+    POOL: AaveV3BNB.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3BNB.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3BNB.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3BNB.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3BNB.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3BNB.ACL_MANAGER,
+    COLLECTOR: AaveV3BNB.COLLECTOR,
+    ORACLE: AaveV3BNB.ORACLE
+  },
+  ["gnosis" /* GNOSIS */]: {
+    POOL: AaveV3Gnosis.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Gnosis.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Gnosis.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Gnosis.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Gnosis.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Gnosis.ACL_MANAGER,
+    COLLECTOR: AaveV3Gnosis.COLLECTOR,
+    ORACLE: AaveV3Gnosis.ORACLE
+  },
+  ["metis" /* METIS */]: {
+    POOL: AaveV3Metis.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Metis.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Metis.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Metis.UI_POOL_DATA_PROVIDER,
+    // WETH_GATEWAY: Not available on Metis
+    ACL_MANAGER: AaveV3Metis.ACL_MANAGER,
+    COLLECTOR: AaveV3Metis.COLLECTOR,
+    ORACLE: AaveV3Metis.ORACLE
+  },
+  ["scroll" /* SCROLL */]: {
+    POOL: AaveV3Scroll.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Scroll.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Scroll.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Scroll.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Scroll.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Scroll.ACL_MANAGER,
+    COLLECTOR: AaveV3Scroll.COLLECTOR,
+    ORACLE: AaveV3Scroll.ORACLE
+  },
+  ["zksync" /* ZKSYNC */]: {
+    POOL: AaveV3ZkSync.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3ZkSync.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3ZkSync.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3ZkSync.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3ZkSync.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3ZkSync.ACL_MANAGER,
+    COLLECTOR: AaveV3ZkSync.COLLECTOR,
+    ORACLE: AaveV3ZkSync.ORACLE
+  },
+  // Testnets
+  ["sepolia" /* SEPOLIA */]: {
+    POOL: AaveV3Sepolia.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Sepolia.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Sepolia.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3Sepolia.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3Sepolia.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Sepolia.ACL_MANAGER,
+    COLLECTOR: AaveV3Sepolia.COLLECTOR,
+    ORACLE: AaveV3Sepolia.ORACLE
+  },
+  ["fuji" /* FUJI */]: {
+    POOL: AaveV3Fuji.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3Fuji.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3Fuji.AAVE_PROTOCOL_DATA_PROVIDER,
+    // UI_POOL_DATA_PROVIDER: Not available on Fuji
+    WETH_GATEWAY: AaveV3Fuji.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3Fuji.ACL_MANAGER,
+    COLLECTOR: AaveV3Fuji.COLLECTOR,
+    ORACLE: AaveV3Fuji.ORACLE
+  },
+  ["arbitrum-sepolia" /* ARBITRUM_SEPOLIA */]: {
+    POOL: AaveV3ArbitrumSepolia.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3ArbitrumSepolia.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3ArbitrumSepolia.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3ArbitrumSepolia.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3ArbitrumSepolia.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3ArbitrumSepolia.ACL_MANAGER,
+    COLLECTOR: AaveV3ArbitrumSepolia.COLLECTOR,
+    ORACLE: AaveV3ArbitrumSepolia.ORACLE
+  },
+  ["optimism-sepolia" /* OPTIMISM_SEPOLIA */]: {
+    POOL: AaveV3OptimismSepolia.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3OptimismSepolia.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3OptimismSepolia.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3OptimismSepolia.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3OptimismSepolia.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3OptimismSepolia.ACL_MANAGER,
+    COLLECTOR: AaveV3OptimismSepolia.COLLECTOR,
+    ORACLE: AaveV3OptimismSepolia.ORACLE
+  },
+  ["base-sepolia" /* BASE_SEPOLIA */]: {
+    POOL: AaveV3BaseSepolia.POOL,
+    POOL_ADDRESSES_PROVIDER: AaveV3BaseSepolia.POOL_ADDRESSES_PROVIDER,
+    AAVE_PROTOCOL_DATA_PROVIDER: AaveV3BaseSepolia.AAVE_PROTOCOL_DATA_PROVIDER,
+    UI_POOL_DATA_PROVIDER: AaveV3BaseSepolia.UI_POOL_DATA_PROVIDER,
+    WETH_GATEWAY: AaveV3BaseSepolia.WETH_GATEWAY,
+    ACL_MANAGER: AaveV3BaseSepolia.ACL_MANAGER,
+    COLLECTOR: AaveV3BaseSepolia.COLLECTOR,
+    ORACLE: AaveV3BaseSepolia.ORACLE
+  }
+};
+function resolveChainContext(chainName) {
+  const normalizedChain = chainName.toLowerCase().trim();
+  if (!Object.values(SupportedChain).includes(normalizedChain)) {
+    throw new AaveError(
+      `Unsupported chain: ${chainName}. Supported chains: ${Object.values(SupportedChain).join(", ")}`,
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */
+    );
+  }
+  const config = CHAIN_CONFIGS[normalizedChain];
+  if (!config) {
+    throw new AaveError(
+      `Chain configuration not found for: ${chainName}`,
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */
+    );
+  }
+  const addresses = CHAIN_ADDRESS_MAP[normalizedChain];
+  if (!addresses) {
+    throw new AaveError(
+      `Aave V3 contracts not available on chain: ${chainName}`,
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */
+    );
+  }
+  return {
+    chain: normalizedChain,
+    config,
+    addresses
+  };
+}
+function resolveRpcUrl(chainContext, userRpcUrl) {
+  if (userRpcUrl) {
+    return userRpcUrl;
+  }
+  return chainContext.config.defaultRpcUrl;
+}
+function isMaxAmount(amount) {
+  if (typeof amount === "string") {
+    const normalized = amount.toLowerCase().trim();
+    return ["max", "maximum", "all", "everything"].includes(normalized);
+  }
+  if (amount instanceof BigNumber3) {
+    return false;
+  }
+  return false;
+}
+function parseAmount(amount) {
+  if (amount === null || amount === void 0) {
+    throw new Error("Amount cannot be null or undefined");
+  }
+  if (typeof amount === "string") {
+    const trimmed = amount.trim();
+    if (!trimmed) {
+      throw new Error("Amount cannot be empty");
+    }
+    if (trimmed === "NaN" || trimmed === "Infinity" || trimmed === "-Infinity") {
+      throw new Error("Invalid amount format");
+    }
+    const num2 = new BigNumber3(trimmed);
+    if (num2.isNaN() || !num2.isFinite()) {
+      throw new Error("Invalid amount format");
+    }
+    if (num2.isLessThanOrEqualTo(0)) {
+      throw new Error("Amount must be greater than 0");
+    }
+    return num2;
+  }
+  if (typeof amount === "number") {
+    if (!isFinite(amount) || isNaN(amount)) {
+      throw new Error("Amount must be a finite number");
+    }
+  }
+  const num = new BigNumber3(amount);
+  if (num.isNaN() || !num.isFinite() || num.isLessThanOrEqualTo(0)) {
+    throw new Error("Amount must be a positive finite number");
+  }
+  return num;
+}
+function validateAddress(address) {
+  if (!address || typeof address !== "string") {
+    throw new Error("Address is required");
+  }
+  const trimmed = address.trim();
+  if (!trimmed.match(/^0x[a-fA-F0-9]{40}$/i)) {
+    throw new Error("Invalid address: must be a valid Ethereum address");
+  }
+  return trimmed;
+}
+function validateSupplyParams(params) {
+  if (!params.user || !params.asset || !params.amount) {
+    throw new Error("Missing required parameters: user, asset, amount");
+  }
+  return {
+    user: validateAddress(params.user),
+    asset: params.asset.trim(),
+    amount: isMaxAmount(params.amount) ? params.amount : parseAmount(params.amount).toString()
+  };
+}
+function validateWithdrawParams(params) {
+  if (!params.user || !params.asset || !params.amount) {
+    throw new Error("Missing required parameters: user, asset, amount");
+  }
+  return {
+    user: validateAddress(params.user),
+    asset: params.asset.trim(),
+    amount: isMaxAmount(params.amount) ? params.amount : parseAmount(params.amount).toString()
+  };
+}
+function validateBorrowParams(params) {
+  if (!params.user || !params.asset || !params.amount) {
+    throw new Error("Missing required parameters: user, asset, amount");
+  }
+  if (params.interestRateMode !== void 0) {
+    if (params.interestRateMode !== 1 /* STABLE */ && params.interestRateMode !== 2 /* VARIABLE */) {
+      throw new Error("Invalid interest rate mode: must be 1 (stable) or 2 (variable)");
+    }
+  }
+  return {
+    user: validateAddress(params.user),
+    asset: params.asset.trim(),
+    amount: parseAmount(params.amount).toString(),
+    interestRateMode: params.interestRateMode || 2 /* VARIABLE */
+  };
+}
+function validateRepayParams(params) {
+  if (!params.user || !params.asset || !params.amount) {
+    throw new Error("Missing required parameters: user, asset, amount");
+  }
+  return {
+    user: validateAddress(params.user),
+    asset: params.asset.trim(),
+    amount: isMaxAmount(params.amount) ? params.amount : parseAmount(params.amount).toString(),
+    interestRateMode: params.interestRateMode || 2 /* VARIABLE */
+  };
+}
+
+// src/utils/error-handler.ts
+function getRateModeName(mode) {
+  switch (mode) {
+    case 1 /* STABLE */:
+      return "Stable";
+    case 2 /* VARIABLE */:
+      return "Variable";
+    default:
+      return "Unknown";
+  }
+}
+var AAVE_PROTOCOL_ERRORS = {
+  // Pool errors (P prefix)
+  "P_INVALID_FLASHLOAN_EXECUTOR_RETURN": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Invalid flashloan executor return",
+    userMessage: "Flash loan execution failed. Please check your flash loan logic.",
+    recovery: {
+      action: "Review and fix your flash loan implementation",
+      requiresUserAction: true
+    }
+  },
+  "P_VT_TRANSFER_NOT_SUPPORTED": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Variable debt token transfer not supported",
+    userMessage: "Cannot transfer debt tokens. Use repay and borrow operations instead.",
+    recovery: {
+      action: "Use repay() and borrow() functions for debt management",
+      requiresUserAction: true
+    }
+  },
+  "P_ASSET_NOT_LISTED": {
+    code: "ASSET_NOT_SUPPORTED" /* ASSET_NOT_SUPPORTED */,
+    description: "Asset is not listed in the pool",
+    userMessage: "This asset is not supported by Aave protocol.",
+    recovery: {
+      action: "Use a supported asset from the Aave markets",
+      requiresUserAction: true
+    }
+  },
+  "P_INVALID_AMOUNT": {
+    code: "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+    description: "Invalid amount provided",
+    userMessage: "The amount provided is invalid. Please check the amount and try again.",
+    recovery: {
+      action: "Ensure amount is positive and within acceptable range",
+      requiresUserAction: true
+    }
+  },
+  // Reserve errors (R prefix)
+  "R_LIQUIDITY_INDEX_OVERFLOW": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Liquidity index overflow",
+    userMessage: "Internal calculation error. Please try again later.",
+    recovery: {
+      action: "Wait and retry the operation",
+      requiresUserAction: false
+    }
+  },
+  "R_VARIABLE_BORROW_INDEX_OVERFLOW": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Variable borrow index overflow",
+    userMessage: "Internal calculation error. Please try again later.",
+    recovery: {
+      action: "Wait and retry the operation",
+      requiresUserAction: false
+    }
+  },
+  "R_LIQUIDITY_RATE_OVERFLOW": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Liquidity rate overflow",
+    userMessage: "Interest rate calculation error. Please try again later.",
+    recovery: {
+      action: "Wait and retry the operation",
+      requiresUserAction: false
+    }
+  },
+  "R_VARIABLE_BORROW_RATE_OVERFLOW": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Variable borrow rate overflow",
+    userMessage: "Interest rate calculation error. Please try again later.",
+    recovery: {
+      action: "Wait and retry the operation",
+      requiresUserAction: false
+    }
+  },
+  // Validation errors (V prefix)
+  "V_INCONSISTENT_FLASHLOAN_PARAMS": {
+    code: "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+    description: "Inconsistent flashloan parameters",
+    userMessage: "Flash loan parameters are inconsistent.",
+    recovery: {
+      action: "Check flash loan asset and amount parameters",
+      requiresUserAction: true
+    }
+  },
+  "V_COLLATERAL_BALANCE_IS_ZERO": {
+    code: "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */,
+    description: "Collateral balance is zero",
+    userMessage: "You have no collateral deposited. Please supply collateral first.",
+    recovery: {
+      action: "Supply assets as collateral before borrowing",
+      requiresUserAction: true
+    }
+  },
+  "V_HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD": {
+    code: "HEALTH_FACTOR_TOO_LOW" /* HEALTH_FACTOR_TOO_LOW */,
+    description: "Health factor below liquidation threshold",
+    userMessage: "This operation would put your position at risk of liquidation.",
+    recovery: {
+      action: "Supply more collateral or reduce borrowing amount",
+      requiresUserAction: true
+    }
+  },
+  "V_COLLATERAL_CANNOT_COVER_NEW_BORROW": {
+    code: "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */,
+    description: "Insufficient collateral for new borrow",
+    userMessage: "You don't have enough collateral to borrow this amount.",
+    recovery: {
+      action: "Supply more collateral or reduce borrow amount",
+      requiresUserAction: true
+    }
+  },
+  "V_STABLE_BORROWING_NOT_ENABLED": {
+    code: "STABLE_BORROWING_NOT_ENABLED" /* STABLE_BORROWING_NOT_ENABLED */,
+    description: "Stable borrowing not enabled for asset",
+    userMessage: "Stable rate borrowing is not available for this asset.",
+    recovery: {
+      action: "Use variable rate borrowing instead",
+      requiresUserAction: true
+    }
+  },
+  "V_NO_DEBT_OF_SELECTED_TYPE": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "No debt of selected type",
+    userMessage: "You don't have debt in the selected interest rate mode.",
+    recovery: {
+      action: "Check your debt positions and select the correct rate mode",
+      requiresUserAction: true
+    }
+  },
+  "V_NO_STABLE_RATE_LOAN_IN_RESERVE": {
+    code: "STABLE_BORROWING_NOT_ENABLED" /* STABLE_BORROWING_NOT_ENABLED */,
+    description: "No stable rate loan exists",
+    userMessage: "No stable rate loan exists for this asset.",
+    recovery: {
+      action: "Use variable rate borrowing",
+      requiresUserAction: true
+    }
+  },
+  "V_NO_VARIABLE_RATE_LOAN_IN_RESERVE": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "No variable rate loan exists",
+    userMessage: "No variable rate loan exists for this asset.",
+    recovery: {
+      action: "Check your borrow positions",
+      requiresUserAction: true
+    }
+  },
+  "V_UNDERLYING_BALANCE_ZERO": {
+    code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+    description: "Underlying balance is zero",
+    userMessage: "You don't have any balance of this asset to supply.",
+    recovery: {
+      action: "Acquire the asset first or check your balance",
+      requiresUserAction: true
+    }
+  },
+  "V_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Interest rate rebalance conditions not met",
+    userMessage: "Cannot rebalance interest rate. Conditions not met.",
+    recovery: {
+      action: "Try again later when market conditions change",
+      requiresUserAction: false
+    }
+  },
+  // Asset configuration errors (A prefix)
+  "A_INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    description: "Rebalance conditions not met",
+    userMessage: "Cannot rebalance stable rate. Market conditions not suitable.",
+    recovery: {
+      action: "Try again when utilization rate changes",
+      requiresUserAction: false
+    }
+  },
+  "A_NO_MORE_RESERVES_ALLOWED": {
+    code: "POOL_PAUSED" /* POOL_PAUSED */,
+    description: "No more reserves allowed",
+    userMessage: "Maximum number of assets reached in the pool.",
+    recovery: {
+      action: "Contact Aave governance to add more reserves",
+      requiresUserAction: true
+    }
+  },
+  // Supply/Withdraw specific
+  "S_NOT_ENOUGH_AVAILABLE_USER_BALANCE": {
+    code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+    description: "Insufficient user balance",
+    userMessage: "You don't have enough balance to complete this operation.",
+    recovery: {
+      action: "Check your wallet balance and reduce the amount",
+      requiresUserAction: true
+    }
+  },
+  "W_NO_ATOKEN_BALANCE": {
+    code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+    description: "No aToken balance to withdraw",
+    userMessage: "You don't have any supplied balance to withdraw.",
+    recovery: {
+      action: "Check your supplied positions",
+      requiresUserAction: true
+    }
+  },
+  // Borrow/Repay specific
+  "B_BORROW_CAP_EXCEEDED": {
+    code: "AMOUNT_TOO_HIGH" /* AMOUNT_TOO_HIGH */,
+    description: "Borrow cap exceeded",
+    userMessage: "Borrowing this amount would exceed the protocol's borrow cap.",
+    recovery: {
+      action: "Reduce the borrow amount",
+      requiresUserAction: true
+    }
+  },
+  "B_SUPPLY_CAP_EXCEEDED": {
+    code: "AMOUNT_TOO_HIGH" /* AMOUNT_TOO_HIGH */,
+    description: "Supply cap exceeded",
+    userMessage: "Supplying this amount would exceed the protocol's supply cap.",
+    recovery: {
+      action: "Reduce the supply amount",
+      requiresUserAction: true
+    }
+  },
+  // Reserve status errors
+  "RESERVE_INACTIVE": {
+    code: "RESERVE_INACTIVE" /* RESERVE_INACTIVE */,
+    description: "Reserve is inactive",
+    userMessage: "This asset is currently inactive in the Aave protocol.",
+    recovery: {
+      action: "Choose an active asset or wait for reactivation",
+      requiresUserAction: true
+    }
+  },
+  "RESERVE_FROZEN": {
+    code: "RESERVE_FROZEN" /* RESERVE_FROZEN */,
+    description: "Reserve is frozen",
+    userMessage: "This asset is currently frozen. Only repay and withdraw operations are allowed.",
+    recovery: {
+      action: "Choose an unfrozen asset or wait for unfreeze",
+      requiresUserAction: true
+    }
+  },
+  "RESERVE_PAUSED": {
+    code: "POOL_PAUSED" /* POOL_PAUSED */,
+    description: "Reserve is paused",
+    userMessage: "Operations on this asset are temporarily paused.",
+    recovery: {
+      action: "Wait for the asset to be unpaused",
+      requiresUserAction: false
+    }
+  }
+};
+var NETWORK_ERROR_PATTERNS = {
+  // RPC errors
+  "network timeout": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Network connection timed out. Please try again.",
+    isRetryable: true
+  },
+  "connection refused": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Unable to connect to the network. Please check your connection.",
+    isRetryable: true
+  },
+  "socket hang up": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Network connection interrupted. Please try again.",
+    isRetryable: true
+  },
+  "request timeout": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Request timed out. Please try again.",
+    isRetryable: true
+  },
+  "rate limit": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Too many requests. Please wait a moment and try again.",
+    isRetryable: true
+  },
+  "insufficient funds for gas": {
+    code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+    userMessage: "Insufficient ETH for gas fees. Please add more ETH to your wallet.",
+    isRetryable: false
+  },
+  "gas limit exceeded": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction requires too much gas. Try reducing the amount.",
+    isRetryable: false
+  },
+  "replacement transaction underpriced": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction replacement fee too low. Increase gas price.",
+    isRetryable: true
+  },
+  "nonce too low": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction nonce is outdated. Please refresh and try again.",
+    isRetryable: true
+  },
+  "already known": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction already pending. Please wait for confirmation.",
+    isRetryable: false
+  }
+};
+var GAS_ERROR_PATTERNS = {
+  "execution reverted": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction would fail. Please check your parameters.",
+    recovery: {
+      action: "Review transaction parameters and account balances",
+      requiresUserAction: true
+    }
+  },
+  "out of gas": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Transaction ran out of gas. Increase gas limit.",
+    recovery: {
+      action: "Increase gas limit or reduce transaction complexity",
+      requiresUserAction: true
+    }
+  },
+  "invalid opcode": {
+    code: "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+    userMessage: "Invalid transaction. Please check your parameters.",
+    recovery: {
+      action: "Verify all transaction parameters are correct",
+      requiresUserAction: true
+    }
+  }
+};
+function mapAaveError(error, context = {}) {
+  const errorMessage = error.message.toLowerCase();
+  for (const [pattern, errorInfo] of Object.entries(AAVE_PROTOCOL_ERRORS)) {
+    if (errorMessage.includes(pattern.toLowerCase()) || errorMessage.includes(`execution reverted: ${pattern.toLowerCase()}`)) {
+      return new AaveError(
+        errorInfo.userMessage,
+        errorInfo.code,
+        error,
+        {
+          ...context,
+          protocolError: pattern,
+          recovery: errorInfo.recovery
+        }
+      );
+    }
+  }
+  for (const [pattern, errorInfo] of Object.entries(NETWORK_ERROR_PATTERNS)) {
+    if (errorMessage.includes(pattern)) {
+      return new AaveError(
+        errorInfo.userMessage,
+        errorInfo.code,
+        error,
+        {
+          ...context,
+          networkError: pattern,
+          isRetryable: errorInfo.isRetryable
+        }
+      );
+    }
+  }
+  for (const [pattern, errorInfo] of Object.entries(GAS_ERROR_PATTERNS)) {
+    if (errorMessage.includes(pattern)) {
+      return new AaveError(
+        errorInfo.userMessage,
+        errorInfo.code,
+        error,
+        {
+          ...context,
+          gasError: pattern,
+          recovery: errorInfo.recovery
+        }
+      );
+    }
+  }
+  if (errorMessage.includes("insufficient")) {
+    if (errorMessage.includes("balance") || errorMessage.includes("funds")) {
+      return new AaveError(
+        "Insufficient balance to complete this operation.",
+        "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+        error,
+        context
+      );
+    }
+    if (errorMessage.includes("collateral")) {
+      return new AaveError(
+        "Insufficient collateral for this operation.",
+        "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */,
+        error,
+        context
+      );
+    }
+  }
+  if (errorMessage.includes("health factor")) {
+    return new AaveError(
+      "This operation would put your position at risk of liquidation.",
+      "HEALTH_FACTOR_TOO_LOW" /* HEALTH_FACTOR_TOO_LOW */,
+      error,
+      context
+    );
+  }
+  if (errorMessage.includes("not enabled") && errorMessage.includes("stable")) {
+    return new AaveError(
+      "Stable rate borrowing is not enabled for this asset.",
+      "STABLE_BORROWING_NOT_ENABLED" /* STABLE_BORROWING_NOT_ENABLED */,
+      error,
+      context
+    );
+  }
+  if (errorMessage.includes("paused")) {
+    return new AaveError(
+      "The pool or asset is currently paused.",
+      "POOL_PAUSED" /* POOL_PAUSED */,
+      error,
+      context
+    );
+  }
+  if (errorMessage.includes("frozen")) {
+    return new AaveError(
+      "The asset is currently frozen.",
+      "RESERVE_FROZEN" /* RESERVE_FROZEN */,
+      error,
+      context
+    );
+  }
+  return new AaveError(
+    "An unexpected error occurred. Please try again.",
+    "UNKNOWN" /* UNKNOWN */,
+    error,
+    context
+  );
+}
+function handleContractError(error, contractName, methodName, context = {}) {
+  const enhancedContext = {
+    ...context,
+    contractName,
+    methodName
+  };
+  const aaveError = mapAaveError(error, enhancedContext);
+  return {
+    originalError: error,
+    aaveError,
+    userMessage: aaveError.message,
+    technicalMessage: `Contract error in ${contractName}.${methodName}: ${error.message}`,
+    context: enhancedContext,
+    isRetryable: determineRetryability(aaveError),
+    logLevel: determineLogLevel(aaveError),
+    recovery: aaveError.context?.recovery
+  };
+}
+function handleTransactionError(error, transactionHash, context = {}) {
+  const enhancedContext = {
+    ...context,
+    transactionHash
+  };
+  const aaveError = mapAaveError(error, enhancedContext);
+  let userMessage = aaveError.message;
+  let technicalMessage = error.message;
+  if (aaveError.code === "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */ && context.operation) {
+    const operation = context.operation;
+    const asset = context.asset || "the asset";
+    switch (operation) {
+      case "supply":
+        userMessage = `You don't have enough ${asset} to supply this amount.`;
+        break;
+      case "borrow":
+        userMessage = `You don't have enough collateral to borrow this amount of ${asset}.`;
+        break;
+      case "repay":
+        userMessage = `You don't have enough ${asset} to repay this amount.`;
+        break;
+      case "withdraw":
+        userMessage = `You don't have enough supplied ${asset} to withdraw this amount.`;
+        break;
+    }
+  }
+  return {
+    originalError: error,
+    aaveError,
+    userMessage,
+    technicalMessage,
+    context: enhancedContext,
+    isRetryable: determineRetryability(aaveError),
+    logLevel: determineLogLevel(aaveError),
+    recovery: generateRecoverySuggestion(aaveError, context)
+  };
+}
+function handleBigNumberError(error, context = {}) {
+  const errorMessage = error.message.toLowerCase();
+  let aaveError;
+  let userMessage;
+  if (errorMessage.includes("invalid number") || errorMessage.includes("not a number")) {
+    aaveError = new AaveError(
+      "Invalid number format provided.",
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+      error,
+      context
+    );
+    userMessage = "Please enter a valid number.";
+  } else if (errorMessage.includes("overflow") || errorMessage.includes("too large")) {
+    aaveError = new AaveError(
+      "Number is too large to process.",
+      "AMOUNT_TOO_HIGH" /* AMOUNT_TOO_HIGH */,
+      error,
+      context
+    );
+    userMessage = "The amount is too large. Please use a smaller number.";
+  } else if (errorMessage.includes("underflow") || errorMessage.includes("negative")) {
+    aaveError = new AaveError(
+      "Negative numbers are not allowed.",
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+      error,
+      context
+    );
+    userMessage = "Please enter a positive number.";
+  } else if (errorMessage.includes("division by zero")) {
+    aaveError = new AaveError(
+      "Division by zero error in calculation.",
+      "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+      error,
+      context
+    );
+    userMessage = "Internal calculation error. Please try again.";
+  } else {
+    aaveError = new AaveError(
+      "Number processing error.",
+      "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+      error,
+      context
+    );
+    userMessage = "There was an error processing the numbers. Please check your input.";
+  }
+  return {
+    originalError: error,
+    aaveError,
+    userMessage,
+    technicalMessage: `BigNumber/ethers error: ${error.message}`,
+    context,
+    isRetryable: false,
+    logLevel: "warn",
+    recovery: {
+      action: "Check input values and try again",
+      requiresUserAction: true
+    }
+  };
+}
+function createSupplyErrorContext(params) {
+  return {
+    operation: "supply",
+    asset: params.asset,
+    amount: params.amount?.toString(),
+    user: params.user
+  };
+}
+function createWithdrawErrorContext(params) {
+  return {
+    operation: "withdraw",
+    asset: params.asset,
+    amount: params.amount?.toString(),
+    user: params.user
+  };
+}
+function createBorrowErrorContext(params) {
+  return {
+    operation: "borrow",
+    asset: params.asset,
+    amount: params.amount?.toString(),
+    user: params.user,
+    interestRateMode: params.interestRateMode
+  };
+}
+function createRepayErrorContext(params) {
+  return {
+    operation: "repay",
+    asset: params.asset,
+    amount: params.amount?.toString(),
+    user: params.user,
+    interestRateMode: params.interestRateMode
+  };
+}
+function determineRetryability(error) {
+  const retryableCodes = [
+    "UNKNOWN" /* UNKNOWN */,
+    "TRANSACTION_FAILED" /* TRANSACTION_FAILED */
+  ];
+  if (retryableCodes.includes(error.code)) {
+    if (error.context?.isRetryable !== void 0) {
+      return error.context.isRetryable;
+    }
+    return true;
+  }
+  const nonRetryableCodes = [
+    "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
+    "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */,
+    "ASSET_NOT_SUPPORTED" /* ASSET_NOT_SUPPORTED */,
+    "INVALID_PARAMETERS" /* INVALID_PARAMETERS */,
+    "HEALTH_FACTOR_TOO_LOW" /* HEALTH_FACTOR_TOO_LOW */,
+    "STABLE_BORROWING_NOT_ENABLED" /* STABLE_BORROWING_NOT_ENABLED */,
+    "AMOUNT_TOO_HIGH" /* AMOUNT_TOO_HIGH */
+  ];
+  return !nonRetryableCodes.includes(error.code);
+}
+function determineLogLevel(error) {
+  switch (error.code) {
+    case "INVALID_PARAMETERS" /* INVALID_PARAMETERS */:
+    case "ASSET_NOT_SUPPORTED" /* ASSET_NOT_SUPPORTED */:
+      return "warn";
+    case "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */:
+    case "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */:
+    case "HEALTH_FACTOR_TOO_LOW" /* HEALTH_FACTOR_TOO_LOW */:
+      return "info";
+    default:
+      return "error";
+  }
+}
+function generateRecoverySuggestion(error, context) {
+  if (error.context?.recovery) {
+    return error.context.recovery;
+  }
+  const { operation, asset, interestRateMode } = context;
+  switch (error.code) {
+    case "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */:
+      if (operation === "supply" || operation === "repay") {
+        return {
+          action: `Acquire more ${asset || "tokens"} or reduce the amount`,
+          requiresUserAction: true
+        };
+      }
+      return {
+        action: "Check your wallet balance and try a smaller amount",
+        requiresUserAction: true
+      };
+    case "INSUFFICIENT_COLLATERAL" /* INSUFFICIENT_COLLATERAL */:
+      return {
+        action: "Supply more collateral or reduce the borrow amount",
+        details: "Your collateral is not sufficient for this borrow amount",
+        requiresUserAction: true
+      };
+    case "HEALTH_FACTOR_TOO_LOW" /* HEALTH_FACTOR_TOO_LOW */:
+      return {
+        action: "Supply additional collateral or repay some debt first",
+        details: "This operation would put your position at risk of liquidation",
+        requiresUserAction: true
+      };
+    case "STABLE_BORROWING_NOT_ENABLED" /* STABLE_BORROWING_NOT_ENABLED */:
+      return {
+        action: "Use variable rate borrowing instead",
+        details: `Stable rate is not available for ${asset || "this asset"}`,
+        requiresUserAction: true
+      };
+    case "ASSET_NOT_SUPPORTED" /* ASSET_NOT_SUPPORTED */:
+      return {
+        action: "Choose a supported asset from the Aave markets",
+        requiresUserAction: true
+      };
+    case "RESERVE_FROZEN" /* RESERVE_FROZEN */:
+      return {
+        action: "Only withdraw and repay operations are allowed for frozen assets",
+        requiresUserAction: true
+      };
+    case "RESERVE_INACTIVE" /* RESERVE_INACTIVE */:
+      return {
+        action: "Choose an active asset or wait for this asset to be reactivated",
+        requiresUserAction: true
+      };
+    case "POOL_PAUSED" /* POOL_PAUSED */:
+      return {
+        action: "Wait for the pool to be unpaused and try again",
+        requiresUserAction: false
+      };
+    default:
+      return {
+        action: "Review the error details and try again",
+        requiresUserAction: true
+      };
+  }
+}
+function formatErrorForLogging(processedError) {
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level: processedError.logLevel,
+    error: {
+      type: processedError.aaveError.name,
+      code: processedError.aaveError.code,
+      message: processedError.technicalMessage,
+      userMessage: processedError.userMessage,
+      stack: processedError.originalError.stack
+    },
+    context: processedError.context,
+    recovery: processedError.recovery,
+    isRetryable: processedError.isRetryable
+  };
+}
+function logError(processedError, logger) {
+  const logData = formatErrorForLogging(processedError);
+  {
+    const logPrefix = `[${processedError.logLevel.toUpperCase()}] Aave Error:`;
+    console[processedError.logLevel === "error" ? "error" : "log"](
+      logPrefix,
+      JSON.stringify(logData, null, 2)
+    );
+  }
+}
+function processError(error, operation, params, transactionHash) {
+  let context;
+  switch (operation) {
+    case "supply":
+      context = createSupplyErrorContext(params || {});
+      break;
+    case "withdraw":
+      context = createWithdrawErrorContext(params || {});
+      break;
+    case "borrow":
+      context = createBorrowErrorContext(params || {});
+      break;
+    case "repay":
+      context = createRepayErrorContext(params || {});
+      break;
+    default:
+      context = { operation };
+  }
+  if (error.message.includes("BigNumber") || error.message.includes("invalid number")) {
+    return handleBigNumberError(error, context);
+  }
+  if (error.message.includes("transaction")) {
+    return handleTransactionError(error, transactionHash, context);
+  }
+  return handleContractError(error, "AavePool", operation, context);
+}
+function createUserFriendlyMessage(error) {
+  const { aaveError, context } = error;
+  const { operation, asset, amount, interestRateMode } = context;
+  let baseMessage = aaveError.message;
+  let operationContext = "";
+  switch (operation) {
+    case "supply":
+      operationContext = `while supplying ${amount ? `${amount} ` : ""}${asset || "tokens"}`;
+      break;
+    case "withdraw":
+      operationContext = `while withdrawing ${amount ? `${amount} ` : ""}${asset || "tokens"}`;
+      break;
+    case "borrow":
+      const rateType = interestRateMode ? getRateModeName(interestRateMode).toLowerCase() : "";
+      operationContext = `while borrowing ${amount ? `${amount} ` : ""}${asset || "tokens"}${rateType ? ` at ${rateType} rate` : ""}`;
+      break;
+    case "repay":
+      const repayRateType = interestRateMode ? getRateModeName(interestRateMode).toLowerCase() : "";
+      operationContext = `while repaying ${amount ? `${amount} ` : ""}${asset || "debt"}${repayRateType ? ` (${repayRateType} rate)` : ""}`;
+      break;
+  }
+  if (operationContext) {
+    baseMessage = `${baseMessage} This error occurred ${operationContext}.`;
+  }
+  if (error.recovery) {
+    baseMessage += ` ${error.recovery.action}.`;
+    if (error.recovery.details) {
+      baseMessage += ` ${error.recovery.details}.`;
+    }
+  }
+  return baseMessage;
+}
+function handleError(error, operation, params, transactionHash, logger) {
+  const processedError = processError(error, operation, params, transactionHash);
+  processedError.userMessage = createUserFriendlyMessage(processedError);
+  logError(processedError);
+  return processedError;
+}
+
+// src/services/aave-service.ts
+var AaveService = class extends Service {
+  static serviceType = "aave";
+  provider;
+  signer;
+  poolService;
+  uiPoolDataProvider;
+  chainContext;
+  isInitialized = false;
+  constructor(runtime) {
+    super(runtime);
+  }
+  get description() {
+    return "Aave V3 Protocol service for lending, borrowing, and DeFi operations";
+  }
+  get capabilityDescription() {
+    const currentChain = this.chainContext?.config?.name || "Multiple chains";
+    return `Supports Aave V3 lending operations on ${currentChain}: supply, withdraw, borrow, repay with aTokens and variable/stable rates`;
+  }
+  async initialize(runtime) {
+    try {
+      elizaLogger.info("Initializing Aave V3 multi-chain service...");
+      const targetChain = runtime.getSetting("AAVE_CHAIN") || "ethereum";
+      elizaLogger.info(`Initializing for chain: ${targetChain}`);
+      this.chainContext = resolveChainContext(targetChain);
+      elizaLogger.info(`Chain context resolved: ${this.chainContext.config.name} (Chain ID: ${this.chainContext.config.chainId})`);
+      const customRpcUrl = runtime.getSetting("AAVE_RPC_URL") || runtime.getSetting("RPC_URL");
+      const rpcUrl = resolveRpcUrl(this.chainContext, customRpcUrl);
+      elizaLogger.info(`Using RPC URL: ${rpcUrl.replace(/\/\/.*@/, "//***@")}`);
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      this.provider = new ethers.providers.JsonRpcProvider(rpcUrl);
+      if (privateKey) {
+        this.signer = new ethers.Wallet(privateKey, this.provider);
+        elizaLogger.info(`Wallet connected: ${this.signer.address} on ${this.chainContext.config.name}`);
+        const network = await this.provider.getNetwork();
+        if (network.chainId !== this.chainContext.config.chainId) {
+          elizaLogger.warn(`Network mismatch: RPC reports chain ID ${network.chainId}, expected ${this.chainContext.config.chainId}`);
+        }
+      }
+      const poolConfig = {
+        POOL: this.chainContext.addresses.POOL
+      };
+      if (this.chainContext.addresses.WETH_GATEWAY) {
+        poolConfig.WETH_GATEWAY = this.chainContext.addresses.WETH_GATEWAY;
+      }
+      this.poolService = new Pool(this.provider, poolConfig);
+      if (this.chainContext.addresses.UI_POOL_DATA_PROVIDER) {
+        this.uiPoolDataProvider = new UiPoolDataProvider({
+          uiPoolDataProviderAddress: this.chainContext.addresses.UI_POOL_DATA_PROVIDER,
+          provider: this.provider,
+          chainId: this.chainContext.config.chainId
+        });
+      }
+      await this.verifyConnection();
+      this.isInitialized = true;
+      elizaLogger.info(`Aave V3 service initialized successfully on ${this.chainContext.config.name}`);
+      elizaLogger.info(`Available assets: ${this.chainContext.config.popularAssets.join(", ")}`);
+    } catch (error) {
+      elizaLogger.error("Failed to initialize Aave service:", error);
+      throw new AaveError(
+        `Failed to initialize Aave V3 service: ${error instanceof Error ? error.message : String(error)}`,
+        "INITIALIZATION_FAILED" /* INITIALIZATION_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        {
+          targetChain: runtime.getSetting("AAVE_CHAIN"),
+          originalError: error
+        }
+      );
+    }
+  }
+  async verifyConnection() {
+    try {
+      if (!this.uiPoolDataProvider) {
+        elizaLogger.warn(`UI Pool Data Provider not available on ${this.chainContext.config.name} - some features may be limited`);
+        return;
+      }
+      const reservesData = await this.uiPoolDataProvider.getReservesHumanized({
+        lendingPoolAddressProvider: this.chainContext.addresses.POOL_ADDRESSES_PROVIDER
+      });
+      if (!reservesData || reservesData.reservesData.length === 0) {
+        throw new Error("No reserves data received from Aave V3 contracts");
+      }
+      elizaLogger.info(`Connected to Aave V3 on ${this.chainContext.config.name} - found ${reservesData.reservesData.length} reserves`);
+      const availableAssets = reservesData.reservesData.map((r) => r.symbol).slice(0, 5);
+      elizaLogger.info(`Sample available assets: ${availableAssets.join(", ")}`);
+    } catch (error) {
+      elizaLogger.error("Connection verification failed:", error);
+      throw new AaveError(
+        `Failed to verify Aave V3 connection on ${this.chainContext.config.name}`,
+        "CONNECTION_FAILED" /* CONNECTION_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        {
+          chain: this.chainContext.config.name,
+          chainId: this.chainContext.config.chainId,
+          poolAddress: this.chainContext.addresses.POOL
+        }
+      );
+    }
+  }
+  ensureInitialized() {
+    if (!this.isInitialized || !this.poolService) {
+      throw new AaveError(
+        "Aave service not initialized",
+        "SERVICE_NOT_INITIALIZED" /* SERVICE_NOT_INITIALIZED */
+      );
+    }
+  }
+  ensureSigner() {
+    if (!this.signer) {
+      throw new AaveError(
+        "Wallet not connected - private key required for transactions",
+        "WALLET_NOT_CONNECTED" /* WALLET_NOT_CONNECTED */
+      );
+    }
+  }
+  async supply(params) {
+    try {
+      this.ensureInitialized();
+      this.ensureSigner();
+      const validatedParams = validateSupplyParams(params);
+      const amount = parseAmount(validatedParams.amount).toString();
+      const userAddress = validatedParams.user;
+      elizaLogger.info(`Supplying ${amount} ${validatedParams.asset} for ${userAddress}`);
+      const reserveData = await this.getReserveData(validatedParams.asset);
+      const supplyTxs = await this.poolService.supply({
+        user: userAddress,
+        reserve: reserveData.underlyingAsset,
+        amount,
+        onBehalfOf: userAddress
+      });
+      if (supplyTxs.length === 0) {
+        throw new AaveError(
+          "Failed to generate supply transaction",
+          "TRANSACTION_GENERATION_FAILED" /* TRANSACTION_GENERATION_FAILED */
+        );
+      }
+      let approvalTxHash;
+      let supplyTxHash;
+      for (const tx of supplyTxs) {
+        const ethersTransaction = {
+          to: tx.to,
+          data: tx.data,
+          value: tx.value || "0",
+          gasLimit: tx.gasLimit
+        };
+        const txResponse = await this.signer.sendTransaction(ethersTransaction);
+        const receipt = await txResponse.wait();
+        if (tx.txType === "ERC20_APPROVAL") {
+          approvalTxHash = receipt.transactionHash;
+          elizaLogger.info(`Token approval completed: ${approvalTxHash}`);
+        } else {
+          supplyTxHash = receipt.transactionHash;
+          elizaLogger.info(`Supply transaction completed: ${supplyTxHash}`);
+        }
+      }
+      const accountData = await this.getUserAccountData(userAddress);
+      const aTokensReceived = new BigNumber3(amount);
+      return {
+        success: true,
+        transactionHash: supplyTxHash,
+        suppliedAmount: new BigNumber3(amount),
+        aTokenAmount: aTokensReceived,
+        newATokenBalance: aTokensReceived,
+        // Simplified - would need to query actual balance
+        gasUsed: new BigNumber3("0")
+        // Would need to calculate from receipt
+      };
+    } catch (error) {
+      elizaLogger.error("Supply operation failed:", error);
+      const processedError = handleError(error instanceof Error ? error : new Error(String(error)), "supply", params);
+      throw new AaveError(
+        processedError.userMessage,
+        "SUPPLY_FAILED" /* SUPPLY_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { operation: "supply", params }
+      );
+    }
+  }
+  async withdraw(params) {
+    try {
+      this.ensureInitialized();
+      this.ensureSigner();
+      const validatedParams = validateWithdrawParams(params);
+      const userAddress = validatedParams.user;
+      elizaLogger.info(`Withdrawing ${validatedParams.amount} ${validatedParams.asset} for ${userAddress}`);
+      const reserveData = await this.getReserveData(validatedParams.asset);
+      let amount;
+      if (isMaxAmount(validatedParams.amount)) {
+        amount = "-1";
+      } else {
+        amount = parseAmount(validatedParams.amount).toString();
+      }
+      const withdrawTxs = await this.poolService.withdraw({
+        user: userAddress,
+        reserve: reserveData.underlyingAsset,
+        amount,
+        onBehalfOf: userAddress
+      });
+      if (withdrawTxs.length === 0) {
+        throw new AaveError(
+          "Failed to generate withdraw transaction",
+          "TRANSACTION_GENERATION_FAILED" /* TRANSACTION_GENERATION_FAILED */
+        );
+      }
+      const tx = withdrawTxs[0];
+      const ethersTransaction = {
+        to: tx.to,
+        data: tx.data,
+        value: tx.value || "0",
+        gasLimit: tx.gasLimit
+      };
+      const txResponse = await this.signer.sendTransaction(ethersTransaction);
+      const receipt = await txResponse.wait();
+      const withdrawTxHash = receipt.transactionHash;
+      elizaLogger.info(`Withdraw transaction completed: ${withdrawTxHash}`);
+      const accountData = await this.getUserAccountData(userAddress);
+      const amountWithdrawn = isMaxAmount(validatedParams.amount) ? new BigNumber3(amount) : parseAmount(validatedParams.amount);
+      return {
+        success: true,
+        transactionHash: withdrawTxHash,
+        amountWithdrawn,
+        remainingATokenBalance: new BigNumber3(0),
+        // Would need to query aToken contract
+        newHealthFactor: accountData.healthFactor.toNumber(),
+        gasUsed: new BigNumber3(receipt.gasUsed.toString())
+      };
+    } catch (error) {
+      elizaLogger.error("Withdraw operation failed:", error);
+      const processedError = handleError(error instanceof Error ? error : new Error(String(error)), "withdraw", params);
+      throw new AaveError(
+        processedError.userMessage,
+        "WITHDRAW_FAILED" /* WITHDRAW_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { operation: "withdraw", params }
+      );
+    }
+  }
+  async borrow(params) {
+    try {
+      this.ensureInitialized();
+      this.ensureSigner();
+      const validatedParams = validateBorrowParams(params);
+      const amount = parseAmount(validatedParams.amount).toString();
+      const userAddress = validatedParams.user;
+      const rateMode = validatedParams.interestRateMode;
+      elizaLogger.info(`Borrowing ${amount} ${validatedParams.asset} for ${userAddress}`);
+      const reserveData = await this.getReserveData(validatedParams.asset);
+      const borrowTxs = await this.poolService.borrow({
+        user: userAddress,
+        reserve: reserveData.underlyingAsset,
+        amount,
+        interestRateMode: rateMode === 1 /* STABLE */ ? 1 : 2,
+        onBehalfOf: userAddress
+      });
+      if (borrowTxs.length === 0) {
+        throw new AaveError(
+          "Failed to generate borrow transaction",
+          "TRANSACTION_GENERATION_FAILED" /* TRANSACTION_GENERATION_FAILED */
+        );
+      }
+      const tx = borrowTxs[0];
+      const ethersTransaction = {
+        to: tx.to,
+        data: tx.data,
+        value: tx.value || "0",
+        gasLimit: tx.gasLimit
+      };
+      const txResponse = await this.signer.sendTransaction(ethersTransaction);
+      const receipt = await txResponse.wait();
+      const borrowTxHash = receipt.transactionHash;
+      elizaLogger.info(`Borrow transaction completed: ${borrowTxHash}`);
+      const accountData = await this.getUserAccountData(userAddress);
+      const borrowAPY = rateMode === 2 /* VARIABLE */ ? Number(reserveData.variableBorrowAPY) : Number(reserveData.stableBorrowAPY);
+      return {
+        success: true,
+        transactionHash: borrowTxHash,
+        amountBorrowed: new BigNumber3(amount),
+        interestRateMode: rateMode,
+        currentBorrowAPY: borrowAPY,
+        newHealthFactor: accountData.healthFactor.toNumber(),
+        gasUsed: new BigNumber3(receipt.gasUsed.toString())
+      };
+    } catch (error) {
+      elizaLogger.error("Borrow operation failed:", error);
+      const processedError = handleError(error instanceof Error ? error : new Error(String(error)), "borrow", params);
+      throw new AaveError(
+        processedError.userMessage,
+        "BORROW_FAILED" /* BORROW_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { operation: "borrow", params }
+      );
+    }
+  }
+  async repay(params) {
+    try {
+      this.ensureInitialized();
+      this.ensureSigner();
+      const validatedParams = validateRepayParams(params);
+      const userAddress = validatedParams.user;
+      const rateMode = validatedParams.interestRateMode;
+      elizaLogger.info(`Repaying ${validatedParams.amount} ${validatedParams.asset} for ${userAddress}`);
+      const reserveData = await this.getReserveData(validatedParams.asset);
+      let amount;
+      if (isMaxAmount(validatedParams.amount)) {
+        amount = "-1";
+      } else {
+        amount = parseAmount(validatedParams.amount).toString();
+      }
+      const repayTxs = await this.poolService.repay({
+        user: userAddress,
+        reserve: reserveData.underlyingAsset,
+        amount,
+        interestRateMode: rateMode === 1 /* STABLE */ ? 1 : 2,
+        onBehalfOf: userAddress
+      });
+      if (repayTxs.length === 0) {
+        throw new AaveError(
+          "Failed to generate repay transaction",
+          "TRANSACTION_GENERATION_FAILED" /* TRANSACTION_GENERATION_FAILED */
+        );
+      }
+      let approvalTxHash;
+      let repayTxHash;
+      for (const tx of repayTxs) {
+        const ethersTransaction = {
+          to: tx.to,
+          data: tx.data,
+          value: tx.value || "0",
+          gasLimit: tx.gasLimit
+        };
+        const txResponse = await this.signer.sendTransaction(ethersTransaction);
+        const receipt = await txResponse.wait();
+        if (tx.txType === "ERC20_APPROVAL") {
+          approvalTxHash = receipt.transactionHash;
+          elizaLogger.info(`Token approval completed: ${approvalTxHash}`);
+        } else {
+          repayTxHash = receipt.transactionHash;
+          elizaLogger.info(`Repay transaction completed: ${repayTxHash}`);
+        }
+      }
+      const accountData = await this.getUserAccountData(userAddress);
+      const amountRepaid = isMaxAmount(validatedParams.amount) ? new BigNumber3(amount === "-1" ? "0" : amount) : parseAmount(validatedParams.amount);
+      return {
+        success: true,
+        transactionHash: repayTxHash,
+        amountRepaid,
+        interestRateMode: rateMode,
+        remainingDebt: accountData.totalDebtETH,
+        newHealthFactor: accountData.healthFactor.toNumber(),
+        gasUsed: new BigNumber3("0"),
+        // Would need to calculate from receipt
+        approvalTransactionHash: approvalTxHash
+      };
+    } catch (error) {
+      elizaLogger.error("Repay operation failed:", error);
+      const processedError = handleError(error instanceof Error ? error : new Error(String(error)), "repay", params);
+      throw new AaveError(
+        processedError.userMessage,
+        "REPAY_FAILED" /* REPAY_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { operation: "repay", params }
+      );
+    }
+  }
+  async getUserPosition(userAddress) {
+    try {
+      this.ensureInitialized();
+      if (!this.uiPoolDataProvider) {
+        throw new AaveError(
+          "UI Pool Data Provider not available on this chain - cannot fetch user positions",
+          "UNSUPPORTED_OPERATION" /* UNSUPPORTED_OPERATION */
+        );
+      }
+      const validatedAddress = validateAddress(userAddress);
+      const userReservesData = await this.uiPoolDataProvider.getUserReservesHumanized({
+        lendingPoolAddressProvider: this.chainContext.addresses.POOL_ADDRESSES_PROVIDER,
+        user: validatedAddress
+      });
+      const reservesData = await this.uiPoolDataProvider.getReservesHumanized({
+        lendingPoolAddressProvider: this.chainContext.addresses.POOL_ADDRESSES_PROVIDER
+      });
+      const formattedPoolReserves = formatReserves({
+        reserves: reservesData.reservesData,
+        currentTimestamp: Date.now() / 1e3,
+        marketReferencePriceInUsd: reservesData.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+        marketReferenceCurrencyDecimals: reservesData.baseCurrencyData.marketReferenceCurrencyDecimals
+      });
+      const userSummary = formatUserSummary({
+        currentTimestamp: Date.now() / 1e3,
+        marketReferencePriceInUsd: reservesData.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+        marketReferenceCurrencyDecimals: reservesData.baseCurrencyData.marketReferenceCurrencyDecimals,
+        userReserves: userReservesData.userReserves,
+        formattedReserves: formattedPoolReserves,
+        userEmodeCategoryId: userReservesData.userEmodeCategoryId
+      });
+      const positions = userReservesData.userReserves.filter(
+        (reserve) => reserve.scaledATokenBalance !== "0" || reserve.scaledVariableDebt !== "0" || reserve.principalStableDebt !== "0"
+      ).map((reserve) => {
+        const poolReserve = formattedPoolReserves.find(
+          (r) => r.underlyingAsset.toLowerCase() === reserve.underlyingAsset.toLowerCase()
+        );
+        return {
+          asset: poolReserve?.symbol || "Unknown",
+          suppliedAmount: new BigNumber3(reserve.scaledATokenBalance || "0"),
+          borrowedAmountVariable: new BigNumber3(reserve.scaledVariableDebt || "0"),
+          borrowedAmountStable: new BigNumber3(reserve.principalStableDebt || "0"),
+          supplyAPY: Number(poolReserve?.supplyAPY || "0"),
+          variableBorrowAPY: Number(poolReserve?.variableBorrowAPY || "0"),
+          stableBorrowAPY: Number(poolReserve?.variableBorrowAPY || "0"),
+          // Use variableBorrowAPY since stableBorrowAPY doesn't exist
+          isCollateral: reserve.usageAsCollateralEnabled,
+          liquidationThreshold: Number(poolReserve?.reserveLiquidationThreshold || "0") / 1e4,
+          ltv: Number(poolReserve?.baseLTVasCollateral || "0") / 1e4
+        };
+      });
+      return {
+        userAddress: validatedAddress,
+        totalCollateralETH: new BigNumber3(userSummary.totalCollateralUSD),
+        totalDebtETH: new BigNumber3(userSummary.totalBorrowsUSD),
+        availableBorrowsETH: new BigNumber3(userSummary.availableBorrowsUSD),
+        currentLiquidationThreshold: Number(userSummary.currentLiquidationThreshold),
+        ltv: Number(userSummary.currentLtv || userSummary.totalLTV || 0),
+        healthFactor: new BigNumber3(userSummary.healthFactor),
+        positions,
+        lastUpdated: Date.now()
+      };
+    } catch (error) {
+      elizaLogger.error("Failed to get user position:", error);
+      throw new AaveError(
+        "Failed to fetch user position",
+        "DATA_FETCH_FAILED" /* DATA_FETCH_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { userAddress }
+      );
+    }
+  }
+  async getUserAccountData(userAddress) {
+    try {
+      this.ensureInitialized();
+      const position = await this.getUserPosition(userAddress);
+      return {
+        totalCollateralETH: position.totalCollateralETH,
+        totalDebtETH: position.totalDebtETH,
+        availableBorrowsETH: position.availableBorrowsETH,
+        currentLiquidationThreshold: position.currentLiquidationThreshold,
+        ltv: position.ltv,
+        healthFactor: position.healthFactor
+      };
+    } catch (error) {
+      elizaLogger.error("Failed to get user account data:", error);
+      throw new AaveError(
+        "Failed to fetch user account data",
+        "DATA_FETCH_FAILED" /* DATA_FETCH_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        { userAddress }
+      );
+    }
+  }
+  async getMarketData() {
+    this.ensureInitialized();
+    try {
+      if (!this.uiPoolDataProvider) {
+        throw new AaveError(
+          "UI Pool Data Provider not available on this chain - cannot fetch market data",
+          "UNSUPPORTED_OPERATION" /* UNSUPPORTED_OPERATION */
+        );
+      }
+      const reservesData = await this.uiPoolDataProvider.getReservesHumanized({
+        lendingPoolAddressProvider: this.chainContext.addresses.POOL_ADDRESSES_PROVIDER
+      });
+      const formattedReserves = formatReserves({
+        reserves: reservesData.reservesData,
+        currentTimestamp: Date.now() / 1e3,
+        marketReferencePriceInUsd: reservesData.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+        marketReferenceCurrencyDecimals: reservesData.baseCurrencyData.marketReferenceCurrencyDecimals
+      });
+      return formattedReserves.map((reserve) => ({
+        asset: reserve.symbol,
+        aTokenAddress: reserve.aTokenAddress,
+        stableDebtTokenAddress: reserve.stableDebtTokenAddress,
+        variableDebtTokenAddress: reserve.variableDebtTokenAddress,
+        underlyingAsset: reserve.underlyingAsset,
+        decimals: reserve.decimals,
+        supplyAPY: Number(reserve.supplyAPY),
+        variableBorrowAPY: Number(reserve.variableBorrowAPY),
+        stableBorrowAPY: Number(reserve.stableBorrowAPY),
+        totalSupply: new BigNumber3(reserve.totalLiquidity),
+        totalBorrow: new BigNumber3(reserve.totalDebt),
+        utilizationRate: Number(reserve.utilizationRate),
+        ltv: Number(reserve.baseLTVasCollateral) / 100,
+        liquidationThreshold: Number(reserve.liquidationThreshold) / 100,
+        liquidationBonus: Number(reserve.liquidationBonus) / 100,
+        reserveFactor: Number(reserve.reserveFactor) / 100,
+        priceInUSD: new BigNumber3(reserve.priceInUSD || "0"),
+        isActive: reserve.isActive,
+        isFrozen: reserve.isFrozen,
+        isPaused: reserve.isPaused,
+        supplyCap: new BigNumber3(reserve.supplyCap || "0"),
+        borrowCap: new BigNumber3(reserve.borrowCap || "0"),
+        lastUpdated: Date.now()
+      }));
+    } catch (error) {
+      elizaLogger.error("Failed to get market data:", error);
+      throw new AaveError(
+        "Failed to fetch market data",
+        "DATA_FETCH_FAILED" /* DATA_FETCH_FAILED */,
+        error instanceof Error ? error : new Error(String(error)),
+        {}
+      );
+    }
+  }
+  async getReserveData(asset) {
+    const marketData = await this.getMarketData();
+    const assetData = marketData.find(
+      (m) => m.asset.toLowerCase() === asset.toLowerCase() || m.underlyingAsset.toLowerCase() === asset.toLowerCase()
+    );
+    if (!assetData) {
+      throw new AaveError(
+        `Asset not found in market data: ${asset}`,
+        "ASSET_NOT_FOUND" /* ASSET_NOT_FOUND */,
+        void 0,
+        { asset }
+      );
+    }
+    return assetData;
+  }
+  async stop() {
+    elizaLogger.info("Stopping Aave service...");
+    this.isInitialized = false;
+  }
+};
+var extractionTemplate = `Given the user's request to supply/deposit assets to Aave, extract the required information.
+
+User request: "{{userMessage}}"
+
+Extract and return ONLY a JSON object with the following structure:
+{
+  "asset": "asset symbol (e.g., USDC, WETH, DAI) or address",
+  "amount": "amount to supply as string (e.g., '100', '0.5')",
+  "userAddress": "user's ethereum address if mentioned, otherwise null"
+}
+
+Important:
+- For ETH mentions, use "WETH" as the asset
+- Amount should be the numeric value only (no symbols)
+- If amount is "all", "max", or "everything", use "max"
+- Asset should be uppercase symbol if recognizable
+
+Return only the JSON object, no other text.`;
+var supplyAction = {
+  name: "SUPPLY_TO_AAVE",
+  description: "Supply assets to Aave V3 to earn yield and receive aTokens",
+  similes: ["DEPOSIT_TO_AAVE", "LEND_TO_AAVE", "SUPPLY_ASSET", "DEPOSIT_ASSET"],
+  examples: [[
+    {
+      name: "User",
+      content: { text: "I want to supply 1000 USDC to Aave" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F3E6} Supplying 1000 USDC to Aave V3...\n\n\u2705 Successfully supplied 1000 USDC\n\u{1F4C4} Transaction: 0x123...abc\n\u{1FA99} Received: 1000 aUSDC (earning yield)\n\u{1F4B0} Current APY: 3.25%",
+        actions: ["SUPPLY_TO_AAVE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "deposit 0.5 ETH to start earning yield" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F3E6} Supplying 0.5 WETH to Aave V3...\n\n\u2705 Successfully supplied 0.5 WETH\n\u{1F4C4} Transaction: 0x456...def\n\u{1FA99} Received: 0.5 aWETH (earning yield)\n\u{1F4B0} Current APY: 2.15%",
+        actions: ["SUPPLY_TO_AAVE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "supply all my DAI to aave for lending" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F3E6} Supplying all available DAI to Aave V3...\n\n\u2705 Successfully supplied 2,500 DAI\n\u{1F4C4} Transaction: 0x789...ghi\n\u{1FA99} Received: 2,500 aDAI (earning yield)\n\u{1F4B0} Current APY: 4.80%",
+        actions: ["SUPPLY_TO_AAVE"]
+      }
+    }
+  ]],
+  async validate(runtime, message, _state) {
+    try {
+      const rpcUrl = runtime.getSetting("AAVE_RPC_URL");
+      if (!rpcUrl) {
+        return false;
+      }
+      const text = message.content.text?.toLowerCase() || "";
+      const supplyKeywords = [
+        "supply",
+        "deposit",
+        "lend",
+        "provide liquidity"
+      ];
+      const hasSupplyKeyword = supplyKeywords.some((keyword) => text.includes(keyword));
+      const hasAmount = /\d+/.test(text) || text.includes("all") || text.includes("max");
+      const hasAsset = /(usdc|usdt|dai|eth|weth|btc|wbtc|aave|link)/i.test(text);
+      return hasSupplyKeyword && (hasAmount || hasAsset);
+    } catch {
+      return false;
+    }
+  },
+  async handler(runtime, message, _state, _options, callback) {
+    const content = message.content.text;
+    if (!content) {
+      const errorMessage = "Please specify the asset and amount to supply to Aave.";
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
+    }
+    let asset = "";
+    let amount = "";
+    let userAddress;
+    try {
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        throw new Error("Aave service not available");
+      }
+      const prompt = extractionTemplate.replace("{{userMessage}}", content);
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+      try {
+        const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+        const parsed = JSON.parse(cleanedResponse);
+        asset = parsed.asset;
+        amount = parsed.amount;
+        userAddress = parsed.userAddress;
+        if (!asset || !amount) {
+          throw new Error("Missing required parameters");
+        }
+      } catch (parseError) {
+        elizaLogger.warn("Failed to parse LLM response, falling back to regex:", parseError);
+        const amountAssetMatch = content.match(/(?:supply|deposit|lend)\s+([a-zA-Z\d.,]+)\s+(\w+)/i);
+        const assetAmountMatch = content.match(/(\w+)\s+([a-zA-Z\d.,]+)/i);
+        if (amountAssetMatch) {
+          amount = amountAssetMatch[1].replace(/,/g, "");
+          asset = amountAssetMatch[2].toUpperCase();
+        } else if (assetAmountMatch && assetAmountMatch[2].match(/^\d/)) {
+          asset = assetAmountMatch[1].toUpperCase();
+          amount = assetAmountMatch[2].replace(/,/g, "");
+        } else {
+          throw new Error("Could not extract asset and amount from request");
+        }
+        if (asset === "ETH") {
+          asset = "WETH";
+        }
+      }
+      const supplyParams = validateSupplyParams({
+        asset,
+        amount,
+        // Let validation handle string to BigNumber conversion
+        user: userAddress || runtime.getSetting("WALLET_ADDRESS")
+      });
+      const result = await aaveService.supply(supplyParams);
+      const successMessage = `\u{1F3E6} **Successfully Supplied to Aave V3**
+
+\u{1F4B0} **Amount**: ${result.suppliedAmount.toFixed(4)} ${asset}
+\u{1FA99} **Received**: ${result.aTokenAmount.toFixed(4)} a${asset}
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+\u{1F4B0} **New aToken Balance**: ${result.newATokenBalance.toFixed(4)} a${asset}
+
+Your a${asset} tokens will automatically earn yield! \u{1F331}`;
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Successfully supplied ${result.suppliedAmount.toFixed(4)} ${asset} to Aave`,
+        success: true,
+        data: {
+          action: "supply",
+          asset,
+          amount: result.suppliedAmount.toString(),
+          aTokensReceived: result.aTokenAmount.toString(),
+          newBalance: result.newATokenBalance.toString(),
+          transactionHash: result.transactionHash
+        }
+      };
+    } catch (error) {
+      elizaLogger.error("Supply action failed:", error);
+      let errorMessage;
+      if (error instanceof Error) {
+        if (error.message.includes("insufficient balance")) {
+          errorMessage = `\u274C Insufficient ${asset} balance. Please check your wallet balance and try again.`;
+        } else if (error.message.includes("allowance")) {
+          errorMessage = `\u274C Token approval required. The transaction will include approval for ${asset}.`;
+        } else if (error.message.includes("reserve inactive")) {
+          errorMessage = `\u274C ${asset} market is currently inactive on Aave. Please try a different asset.`;
+        } else if (error.message.includes("supply cap")) {
+          errorMessage = `\u274C ${asset} supply cap reached on Aave. Please try a different asset or smaller amount.`;
+        } else {
+          errorMessage = `\u274C Supply failed: ${error.message}`;
+        }
+      } else {
+        errorMessage = "\u274C Supply failed due to an unknown error. Please try again.";
+      }
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false,
+        data: {
+          action: "supply",
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  }
+};
+var extractionTemplate2 = `Given the user's request to withdraw/redeem assets from Aave, extract the required information.
+
+User request: "{{userMessage}}"
+
+Extract and return ONLY a JSON object with the following structure:
+{
+  "asset": "asset symbol (e.g., USDC, WETH, DAI) or address",
+  "amount": "amount to withdraw as string (e.g., '100', '0.5', 'max')",
+  "userAddress": "user's ethereum address if mentioned, otherwise null"
+}
+
+Important:
+- For ETH mentions, use "WETH" as the asset
+- Amount should be the numeric value only (no symbols)
+- If amount is "all", "max", "everything", or similar, use "max"
+- Asset should be uppercase symbol if recognizable
+
+Return only the JSON object, no other text.`;
+var withdrawAction = {
+  name: "WITHDRAW_FROM_AAVE",
+  description: "Withdraw supplied assets from Aave V3 by redeeming aTokens",
+  similes: ["REDEEM_FROM_AAVE", "UNSTAKE_FROM_AAVE", "WITHDRAW_ASSET", "REDEEM_ATOKEN"],
+  examples: [[
+    {
+      name: "User",
+      content: { text: "I want to withdraw 500 USDC from Aave" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F4B8} Withdrawing 500 USDC from Aave V3...\n\n\u2705 Successfully withdrew 500 USDC\n\u{1F4C4} Transaction: 0x123...abc\n\u{1F525} Burned: 500 aUSDC\n\u{1F4B0} Remaining balance: 1,500 aUSDC\n\u{1F4CA} Earning: 3.25% APY on remaining balance",
+        actions: ["WITHDRAW_FROM_AAVE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "redeem 0.1 ETH from my aave position" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F4B8} Withdrawing 0.1 WETH from Aave V3...\n\n\u2705 Successfully withdrew 0.1 WETH\n\u{1F4C4} Transaction: 0x456...def\n\u{1F525} Burned: 0.1 aWETH\n\u{1F4B0} Remaining balance: 0.9 aWETH\n\u{1F4CA} Earning: 2.15% APY on remaining balance",
+        actions: ["WITHDRAW_FROM_AAVE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "withdraw all my DAI from aave lending" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F4B8} Withdrawing all available DAI from Aave V3...\n\n\u2705 Successfully withdrew 2,500 DAI\n\u{1F4C4} Transaction: 0x789...ghi\n\u{1F525} Burned: 2,500 aDAI\n\u{1F4B0} Remaining balance: 0 aDAI\n\u{1F389} Position fully withdrawn!",
+        actions: ["WITHDRAW_FROM_AAVE"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "can I get my 100 USDT back from aave?" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "\u{1F4B8} Withdrawing 100 USDT from Aave V3...\n\n\u2705 Successfully withdrew 100 USDT\n\u{1F4C4} Transaction: 0xabc...xyz\n\u{1F525} Burned: 100 aUSDT\n\u{1F4B0} Remaining balance: 400 aUSDT\n\u{1F4CA} Earning: 4.10% APY on remaining balance",
+        actions: ["WITHDRAW_FROM_AAVE"]
+      }
+    }
+  ]],
+  async validate(runtime, message, _state) {
+    try {
+      const rpcUrl = runtime.getSetting("AAVE_RPC_URL");
+      if (!rpcUrl) {
+        return false;
+      }
+      const text = message.content.text?.toLowerCase() || "";
+      const withdrawKeywords = [
+        "withdraw",
+        "redeem",
+        "unstake",
+        "take out",
+        "get back",
+        "withdraw from aave",
+        "redeem from aave",
+        "unstake from aave",
+        "cash out",
+        "exit position"
+      ];
+      return withdrawKeywords.some((keyword) => text.includes(keyword));
+    } catch {
+      return false;
+    }
+  },
+  async handler(runtime, message, _state, _options, callback) {
+    const content = message.content.text;
+    if (!content) {
+      const errorMessage = "Please specify the asset and amount to withdraw from Aave.";
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
+    }
+    let asset = "";
+    let amount = "";
+    let userAddress;
+    try {
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        throw new Error("Aave service not available");
+      }
+      const prompt = extractionTemplate2.replace("{{userMessage}}", content);
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+      try {
+        const cleanedResponse = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+        const parsed = JSON.parse(cleanedResponse);
+        asset = parsed.asset;
+        amount = parsed.amount;
+        userAddress = parsed.userAddress;
+        if (!asset || !amount) {
+          throw new Error("Missing required parameters");
+        }
+      } catch (parseError) {
+        elizaLogger.warn("Failed to parse LLM response, falling back to regex:", parseError);
+        const amountAssetMatch = content.match(/(?:withdraw|redeem|get.*back)\s+([a-zA-Z\d.,]+)\s+(\w+)/i);
+        const assetAmountMatch = content.match(/(\w+)\s+([a-zA-Z\d.,]+)/i);
+        const maxPatterns = /(?:withdraw|redeem|get).*(?:all|max|everything|full)/i;
+        if (amountAssetMatch) {
+          amount = amountAssetMatch[1].replace(/,/g, "");
+          asset = amountAssetMatch[2].toUpperCase();
+        } else if (assetAmountMatch && assetAmountMatch[2].match(/^\d/)) {
+          asset = assetAmountMatch[1].toUpperCase();
+          amount = assetAmountMatch[2].replace(/,/g, "");
+        } else if (maxPatterns.test(content)) {
+          const assetMatch = content.match(/(?:withdraw|redeem).*?(USDC|WETH|ETH|DAI|USDT|WBTC|LINK|UNI|AAVE|CRV|COMP)/i);
+          if (assetMatch) {
+            asset = assetMatch[1].toUpperCase();
+            amount = "max";
+          } else {
+            throw new Error("Could not extract asset from request");
+          }
+        } else {
+          throw new Error("Could not extract asset and amount from request");
+        }
+        if (asset === "ETH") {
+          asset = "WETH";
+        }
+      }
+      const withdrawParams = validateWithdrawParams({
+        asset,
+        amount,
+        // Let validation handle string to BigNumber conversion
+        user: userAddress || runtime.getSetting("WALLET_ADDRESS")
+      });
+      const result = await aaveService.withdraw(withdrawParams);
+      let successMessage;
+      if (result.remainingATokenBalance.isZero()) {
+        successMessage = `\u{1F4B8} **Successfully Withdrew from Aave V3**
+
+\u{1F389} **Full Withdrawal Complete!**
+\u{1F4B0} **Amount**: ${result.amountWithdrawn.toFixed(4)} ${asset}
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+\u{1F4B0} **Remaining Balance**: 0 a${asset}
+
+Your position has been fully withdrawn! \u{1F3C1}`;
+      } else {
+        successMessage = `\u{1F4B8} **Successfully Withdrew from Aave V3**
+
+\u{1F4B0} **Amount**: ${result.amountWithdrawn.toFixed(4)} ${asset}
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+\u{1F4B0} **Remaining Balance**: ${result.remainingATokenBalance.toFixed(4)} a${asset}
+
+Your remaining a${asset} tokens continue earning yield! \u{1F331}`;
+      }
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Successfully withdrew ${result.amountWithdrawn.toFixed(4)} ${asset} from Aave`,
+        success: true,
+        data: {
+          action: "withdraw",
+          asset,
+          amount: result.amountWithdrawn.toString(),
+          remainingBalance: result.remainingATokenBalance.toString(),
+          transactionHash: result.transactionHash,
+          isFullWithdrawal: result.remainingATokenBalance.isZero()
+        }
+      };
+    } catch (error) {
+      elizaLogger.error("Withdraw action failed:", error);
+      let errorMessage;
+      if (error instanceof Error) {
+        if (error.message.includes("insufficient atoken") || error.message.includes("no atoken balance")) {
+          errorMessage = `\u274C Insufficient a${asset || "Token"} balance. You don't have enough supplied to withdraw this amount.`;
+        } else if (error.message.includes("exceeds balance")) {
+          errorMessage = `\u274C Withdrawal amount exceeds your a${asset || "Token"} balance. Check your supplied position and try a smaller amount.`;
+        } else if (error.message.includes("reserve frozen")) {
+          errorMessage = `\u274C ${asset || "Asset"} withdrawals are currently frozen on Aave. Only emergency withdrawals may be available.`;
+        } else if (error.message.includes("reserve paused")) {
+          errorMessage = `\u274C ${asset || "Asset"} operations are temporarily paused on Aave. Please try again later.`;
+        } else if (error.message.includes("health factor")) {
+          errorMessage = `\u274C Cannot withdraw - would leave position with insufficient collateral. Supply more collateral or reduce borrows first.`;
+        } else if (error.message.includes("reserve inactive")) {
+          errorMessage = `\u274C ${asset || "Asset"} market is currently inactive on Aave. Please try a different asset.`;
+        } else {
+          errorMessage = `\u274C Withdrawal failed: ${error.message}`;
+        }
+      } else {
+        errorMessage = "\u274C Withdrawal failed due to an unknown error. Please try again.";
+      }
+      await callback?.({
+        text: errorMessage,
+        source: message.content.source
+      });
+      return {
+        text: errorMessage,
+        success: false,
+        data: {
+          action: "withdraw",
+          error: error instanceof Error ? error.message : "Unknown error"
+        }
+      };
+    }
+  }
+};
+var borrowAction = {
+  name: "AAVE_BORROW",
+  similes: [
+    "BORROW_FROM_AAVE",
+    "AAVE_LOAN",
+    "TAKE_LOAN",
+    "BORROW_ASSET",
+    "DEFI_BORROW"
+  ],
+  description: "Borrow assets from Aave V3 protocol with specified interest rate mode",
+  validate: async (runtime, message) => {
+    const content = message.content?.text?.toLowerCase();
+    if (!content) return false;
+    const borrowKeywords = [
+      "borrow",
+      "loan",
+      "take loan",
+      "get loan",
+      "variable rate",
+      "stable rate",
+      "interest rate"
+    ];
+    const hasBorrowKeyword = borrowKeywords.some(
+      (keyword) => content.includes(keyword)
+    );
+    if (!hasBorrowKeyword) return false;
+    const hasAssetOrAmount = /\b(usdc|usdt|dai|eth|weth|btc|wbtc|\d+\.?\d*)\b/i.test(content);
+    return hasAssetOrAmount;
+  },
+  examples: [[
+    {
+      name: "User",
+      content: { text: "I want to borrow 1000 USDC with variable rate from Aave" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll help you borrow 1000 USDC with variable interest rate from Aave V3.",
+        actions: ["AAVE_BORROW"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "Take a loan of 0.5 ETH with stable rate" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll process your loan of 0.5 ETH with stable interest rate from Aave.",
+        actions: ["AAVE_BORROW"]
+      }
+    }
+  ]],
+  handler: async (runtime, message, state, options, callback) => {
+    try {
+      elizaLogger.info("Starting Aave borrow operation...");
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        throw new Error("Aave service not available");
+      }
+      const content = message.content?.text;
+      if (!content) {
+        throw new Error("No message content provided");
+      }
+      let asset = "";
+      let amount = "";
+      let rateMode = 2 /* VARIABLE */;
+      const amountAssetMatch = content.match(/(?:borrow|loan|take loan|get loan)(?:\s+of)?\s+([a-zA-Z\d.,]+)\s+(\w+)/i);
+      const assetAmountMatch = content.match(/(\w+)\s+([a-zA-Z\d.,]+)/i);
+      if (amountAssetMatch) {
+        amount = amountAssetMatch[1].replace(/,/g, "");
+        asset = amountAssetMatch[2].toUpperCase();
+      } else if (assetAmountMatch && assetAmountMatch[2].match(/^\d/)) {
+        asset = assetAmountMatch[1].toUpperCase();
+        amount = assetAmountMatch[2].replace(/,/g, "");
+      } else {
+        throw new Error('Could not extract asset and amount from request. Please specify like "borrow 1000 USDC"');
+      }
+      if (content.toLowerCase().includes("stable")) {
+        rateMode = 1 /* STABLE */;
+      }
+      if (asset === "ETH") {
+        asset = "WETH";
+      }
+      const userAddress = runtime.getSetting("WALLET_ADDRESS");
+      if (!userAddress) {
+        throw new Error("Wallet address not configured. Please set WALLET_ADDRESS in settings.");
+      }
+      const parsedAmount = parseAmount(amount);
+      elizaLogger.info(`Borrowing ${parsedAmount} ${asset} with ${rateMode === 1 /* STABLE */ ? "stable" : "variable"} rate for ${userAddress}`);
+      const params = {
+        asset,
+        amount: parsedAmount,
+        interestRateMode: rateMode,
+        user: userAddress
+      };
+      const result = await aaveService.borrow(params);
+      if (!result.success) {
+        throw new Error(`Borrow operation failed: ${result.error?.message}`);
+      }
+      const rateTypeText = rateMode === 1 /* STABLE */ ? "stable" : "variable";
+      const successMessage = `\u{1F4B0} **Successfully Borrowed from Aave V3**
+
+\u{1F389} **Loan Approved!**
+\u{1F4B8} **Amount**: ${result.amountBorrowed.toFixed(4)} ${asset}
+\u{1F4C8} **Interest Rate**: ${rateTypeText.charAt(0).toUpperCase() + rateTypeText.slice(1)} (${result.currentBorrowAPY.toFixed(2)}% APY)
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+\u{1F3E5} **Health Factor**: ${result.newHealthFactor.toFixed(3)}
+
+${result.newHealthFactor < 1.5 ? "\u26A0\uFE0F  **Warning**: Your health factor is getting low. Consider adding more collateral!" : "\u2705 Your position looks healthy! Monitor your health factor regularly."}`;
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Successfully borrowed ${result.amountBorrowed.toFixed(4)} ${asset} from Aave`,
+        success: true,
+        data: {
+          action: "borrow",
+          asset,
+          amount: result.amountBorrowed.toString(),
+          interestRateMode: rateTypeText,
+          currentAPY: result.currentBorrowAPY,
+          transactionHash: result.transactionHash,
+          healthFactor: result.newHealthFactor
+        }
+      };
+    } catch (error) {
+      elizaLogger.error("Borrow action failed:", error);
+      let errorMessage;
+      if (error instanceof Error) {
+        if (error.message.includes("insufficient collateral")) {
+          errorMessage = `\u274C **Insufficient Collateral**
+
+You don't have enough collateral to borrow this amount. 
+\u{1F4A1} **Try this:**
+\u2022 Supply more assets as collateral first
+\u2022 Reduce the borrow amount
+\u2022 Check your health factor`;
+        } else if (error.message.includes("borrowing not enabled")) {
+          errorMessage = `\u274C **Borrowing Not Available**
+
+This asset cannot be borrowed on Aave V3 currently.
+\u{1F4A1} **Try borrowing a different asset like USDC, USDT, or DAI**`;
+        } else if (error.message.includes("health factor")) {
+          errorMessage = `\u274C **Health Factor Too Low**
+
+This borrow would put your position at risk of liquidation.
+\u{1F4A1} **Add more collateral or reduce borrow amount**`;
+        } else {
+          errorMessage = `\u274C **Borrow Failed**: ${error.message}`;
+        }
+      } else {
+        errorMessage = "\u274C **Borrow operation failed**. Please try again or check your parameters.";
+      }
+      await callback?.({
+        text: errorMessage,
+        error: true
+      });
+      return {
+        text: error instanceof Error ? error.message : "Borrow operation failed",
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+};
+var repayAction = {
+  name: "AAVE_REPAY",
+  similes: [
+    "REPAY_TO_AAVE",
+    "AAVE_REPAYMENT",
+    "PAY_BACK",
+    "REPAY_DEBT",
+    "DEFI_REPAY",
+    "PAYBACK_LOAN"
+  ],
+  description: "Repay borrowed assets to Aave V3 protocol",
+  validate: async (runtime, message) => {
+    const content = message.content?.text?.toLowerCase();
+    if (!content) return false;
+    const repayKeywords = [
+      "repay",
+      "pay back",
+      "payback",
+      "pay off",
+      "repayment",
+      "debt",
+      "loan repay",
+      "close position"
+    ];
+    const hasRepayKeyword = repayKeywords.some(
+      (keyword) => content.includes(keyword)
+    );
+    if (!hasRepayKeyword) return false;
+    const hasAssetOrAmount = /\b(usdc|usdt|dai|eth|weth|btc|wbtc|\d+\.?\d*|all|everything|max|maximum)\b/i.test(content);
+    return hasAssetOrAmount;
+  },
+  examples: [[
+    {
+      name: "User",
+      content: { text: "I want to repay 1000 USDC variable debt to Aave" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll help you repay 1000 USDC variable debt to Aave V3.",
+        actions: ["AAVE_REPAY"]
+      }
+    }
+  ], [
+    {
+      name: "User",
+      content: { text: "Pay back all my ETH debt with stable rate" }
+    },
+    {
+      name: "Assistant",
+      content: {
+        text: "I'll process the full repayment of your ETH stable debt.",
+        actions: ["AAVE_REPAY"]
+      }
+    }
+  ]],
+  handler: async (runtime, message, state, options, callback) => {
+    let asset = "";
+    let amount = "";
+    try {
+      elizaLogger.info("Starting Aave repay operation...");
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        throw new Error("Aave service not available");
+      }
+      const content = message.content?.text;
+      if (!content) {
+        throw new Error("No message content provided");
+      }
+      let rateMode = 2 /* VARIABLE */;
+      const amountAssetMatch = content.match(/(?:repay|pay back|payback|pay off)(?:\s+(?:all|full|maximum|max))?\s+([a-zA-Z\d.,]+)\s+(\w+)/i);
+      const assetAmountMatch = content.match(/(\w+)\s+([a-zA-Z\d.,]+)/i);
+      const maxRepayMatch = content.match(/(?:repay|pay back|payback|pay off)\s+(?:all|full|maximum|max|everything)(?:\s+(\w+))?/i);
+      if (maxRepayMatch) {
+        amount = "max";
+        asset = maxRepayMatch[1]?.toUpperCase() || "USDC";
+      } else if (amountAssetMatch) {
+        amount = amountAssetMatch[1].replace(/,/g, "");
+        asset = amountAssetMatch[2].toUpperCase();
+      } else if (assetAmountMatch && assetAmountMatch[2].match(/^\d/)) {
+        asset = assetAmountMatch[1].toUpperCase();
+        amount = assetAmountMatch[2].replace(/,/g, "");
+      } else {
+        throw new Error('Could not extract asset and amount from request. Please specify like "repay 1000 USDC"');
+      }
+      if (content.toLowerCase().includes("stable")) {
+        rateMode = 1 /* STABLE */;
+      }
+      if (asset === "ETH") {
+        asset = "WETH";
+      }
+      const userAddress = runtime.getSetting("WALLET_ADDRESS");
+      if (!userAddress) {
+        throw new Error("Wallet address not configured. Please set WALLET_ADDRESS in settings.");
+      }
+      const parsedAmount = parseAmount(amount);
+      const isFullRepayment = isMaxAmount(parsedAmount);
+      elizaLogger.info(`Repaying ${isFullRepayment ? "full" : amount} ${asset} ${rateMode === 1 /* STABLE */ ? "stable" : "variable"} debt for ${userAddress}`);
+      const params = {
+        asset,
+        amount: parsedAmount,
+        interestRateMode: rateMode,
+        user: userAddress
+      };
+      const result = await aaveService.repay(params);
+      if (!result.success) {
+        throw new Error(`Repay operation failed: ${result.error?.message}`);
+      }
+      const rateTypeText = rateMode === 1 /* STABLE */ ? "stable" : "variable";
+      let successMessage;
+      if (result.remainingDebt.isZero()) {
+        successMessage = `\u{1F4B8} **Successfully Repaid Debt to Aave V3**
+
+\u{1F389} **Debt Fully Repaid!**
+\u{1F4B0} **Amount**: ${result.amountRepaid.toFixed(4)} ${asset}
+\u{1F4C8} **Debt Type**: ${rateTypeText.charAt(0).toUpperCase() + rateTypeText.slice(1)} rate
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+${result.approvalTransactionHash ? `\u{1F513} **Approval**: ${result.approvalTransactionHash}` : ""}
+\u{1F3E5} **Health Factor**: ${result.newHealthFactor.toFixed(3)}
+\u{1F4B0} **Remaining Debt**: $0.00
+
+\u{1F38A} Congratulations! You've completely paid off your ${asset} debt!`;
+      } else {
+        successMessage = `\u{1F4B8} **Successfully Repaid Debt to Aave V3**
+
+\u{1F4B0} **Amount**: ${result.amountRepaid.toFixed(4)} ${asset}
+\u{1F4C8} **Debt Type**: ${rateTypeText.charAt(0).toUpperCase() + rateTypeText.slice(1)} rate
+\u{1F4C4} **Transaction**: ${result.transactionHash}
+${result.approvalTransactionHash ? `\u{1F513} **Approval**: ${result.approvalTransactionHash}` : ""}
+\u{1F3E5} **Health Factor**: ${result.newHealthFactor.toFixed(3)}
+\u{1F4B0} **Remaining Debt**: ${result.remainingDebt.toFixed(4)} ETH equivalent
+
+\u2705 Your position health has improved!`;
+      }
+      await callback?.({
+        text: successMessage,
+        source: message.content.source
+      });
+      return {
+        text: `Successfully repaid ${result.amountRepaid.toFixed(4)} ${asset} to Aave`,
+        success: true,
+        data: {
+          action: "repay",
+          asset,
+          amount: result.amountRepaid.toString(),
+          interestRateMode: rateTypeText,
+          transactionHash: result.transactionHash,
+          approvalTransactionHash: result.approvalTransactionHash,
+          healthFactor: result.newHealthFactor,
+          remainingDebt: result.remainingDebt.toString(),
+          isFullRepayment: result.remainingDebt.isZero()
+        }
+      };
+    } catch (error) {
+      elizaLogger.error("Repay action failed:", error);
+      let errorMessage;
+      if (error instanceof Error) {
+        if (error.message.includes("insufficient balance")) {
+          errorMessage = `\u274C **Insufficient Balance**
+
+You don't have enough ${asset || "tokens"} to repay this amount.
+\u{1F4A1} **Try this:**
+\u2022 Check your wallet balance
+\u2022 Reduce the repay amount
+\u2022 Get more tokens first`;
+        } else if (error.message.includes("no debt")) {
+          errorMessage = `\u274C **No Debt Found**
+
+You don't have any debt for this asset/rate type on Aave V3.
+\u{1F4A1} **Check your position to see current debts**`;
+        } else if (error.message.includes("allowance")) {
+          errorMessage = `\u274C **Token Approval Failed**
+
+Could not approve tokens for repayment.
+\u{1F4A1} **This might be a temporary issue - please try again**`;
+        } else {
+          errorMessage = `\u274C **Repay Failed**: ${error.message}`;
+        }
+      } else {
+        errorMessage = "\u274C **Repayment operation failed**. Please try again or check your parameters.";
+      }
+      await callback?.({
+        text: errorMessage,
+        error: true
+      });
+      return {
+        text: error instanceof Error ? error.message : "Repay operation failed",
+        success: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      };
+    }
+  }
+};
+var marketDataProvider = {
+  name: "AAVE_MARKET_DATA",
+  get: async (runtime, message, state) => {
+    try {
+      elizaLogger.info("Fetching Aave V3 market data...");
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        return { text: "Aave service not available - cannot fetch market data." };
+      }
+      const marketData = await aaveService.getMarketData();
+      if (!marketData || marketData.length === 0) {
+        return { text: "No market data available for Aave V3 at this time." };
+      }
+      const majorAssets = marketData.filter((data) => ["USDC", "USDT", "DAI", "WETH", "ETH", "WBTC", "BTC"].includes(data.asset)).sort((a, b) => {
+        const comparison = b.totalSupply.comparedTo(a.totalSupply);
+        return comparison === null ? 0 : comparison;
+      }).slice(0, 8);
+      if (majorAssets.length === 0) {
+        return { text: "Market data not available for major assets." };
+      }
+      let marketSummary = `\u{1F4CA} **Aave V3 Market Overview** (Ethereum)
+
+`;
+      const totalLiquidity = majorAssets.reduce(
+        (sum, asset) => sum.plus(asset.totalSupply),
+        new BigNumber3(0)
+      );
+      const avgSupplyAPY = majorAssets.reduce(
+        (sum, asset) => sum + asset.supplyAPY,
+        0
+      ) / majorAssets.length;
+      marketSummary += `\u{1F4B0} **Total Liquidity**: $${formatLargeNumber(totalLiquidity)} across major assets
+`;
+      marketSummary += `\u{1F4C8} **Avg Supply APY**: ${avgSupplyAPY.toFixed(2)}%
+
+`;
+      marketSummary += `**\u{1F3E6} Lending Rates:**
+`;
+      marketSummary += `\`\`\`
+`;
+      marketSummary += `Asset   Supply APY  Borrow APY  Utilization
+`;
+      marketSummary += `\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`;
+      for (const asset of majorAssets) {
+        const assetSymbol = asset.asset.padEnd(6);
+        const supplyRate = `${asset.supplyAPY.toFixed(2)}%`.padStart(9);
+        const borrowRate = `${asset.variableBorrowAPY.toFixed(2)}%`.padStart(9);
+        const utilization = `${(asset.utilizationRate * 100).toFixed(1)}%`.padStart(9);
+        marketSummary += `${assetSymbol}  ${supplyRate}  ${borrowRate}   ${utilization}
+`;
+      }
+      marketSummary += `\`\`\`
+
+`;
+      const highYieldAssets = majorAssets.filter((asset) => asset.supplyAPY > 3).sort((a, b) => b.supplyAPY - a.supplyAPY);
+      const lowBorrowCostAssets = majorAssets.filter((asset) => asset.variableBorrowAPY < 5).sort((a, b) => a.variableBorrowAPY - b.variableBorrowAPY);
+      if (highYieldAssets.length > 0) {
+        marketSummary += `\u{1F31F} **High Yield Opportunities:**
+`;
+        highYieldAssets.slice(0, 3).forEach((asset) => {
+          marketSummary += `\u2022 ${asset.asset}: ${asset.supplyAPY.toFixed(2)}% APY
+`;
+        });
+        marketSummary += `
+`;
+      }
+      if (lowBorrowCostAssets.length > 0) {
+        marketSummary += `\u{1F4B8} **Low Borrow Costs:**
+`;
+        lowBorrowCostAssets.slice(0, 3).forEach((asset) => {
+          marketSummary += `\u2022 ${asset.asset}: ${asset.variableBorrowAPY.toFixed(2)}% APY
+`;
+        });
+        marketSummary += `
+`;
+      }
+      const highUtilAssets = majorAssets.filter((asset) => asset.utilizationRate > 0.8);
+      if (highUtilAssets.length > 0) {
+        marketSummary += `\u26A0\uFE0F  **High Utilization Warning:**
+`;
+        highUtilAssets.forEach((asset) => {
+          marketSummary += `\u2022 ${asset.asset}: ${(asset.utilizationRate * 100).toFixed(1)}% utilized
+`;
+        });
+        marketSummary += `Higher utilization may impact liquidity and rates.
+
+`;
+      }
+      marketSummary += `\u{1F4C5} *Data updated: ${(/* @__PURE__ */ new Date()).toLocaleString()}*`;
+      return { text: marketSummary };
+    } catch (error) {
+      elizaLogger.error("Failed to get market data:", error);
+      return { text: "Unable to fetch current market data from Aave V3. Please try again later." };
+    }
+  }
+};
+function formatLargeNumber(num) {
+  if (num.isGreaterThanOrEqualTo(1e9)) {
+    return `${num.dividedBy(1e9).toFixed(1)}B`;
+  } else if (num.isGreaterThanOrEqualTo(1e6)) {
+    return `${num.dividedBy(1e6).toFixed(1)}M`;
+  } else if (num.isGreaterThanOrEqualTo(1e3)) {
+    return `${num.dividedBy(1e3).toFixed(1)}K`;
+  }
+  return num.toFixed(2);
+}
+var positionProvider = {
+  name: "AAVE_POSITION",
+  get: async (runtime, message, state) => {
+    try {
+      elizaLogger.info("Fetching user Aave V3 position...");
+      const userAddress = runtime.getSetting("WALLET_ADDRESS");
+      if (!userAddress) {
+        return { text: "Wallet address not configured. Please set WALLET_ADDRESS to view your position." };
+      }
+      const aaveService = runtime.getService("aave");
+      if (!aaveService) {
+        return { text: "Aave service not available - cannot fetch position data." };
+      }
+      const position = await aaveService.getUserPosition(userAddress);
+      if (!position) {
+        return { text: "Unable to fetch your Aave V3 position at this time." };
+      }
+      const hasSupplyPositions = position.positions.some((p) => p.suppliedAmount.isGreaterThan(0));
+      const hasBorrowPositions = position.positions.some(
+        (p) => p.borrowedAmountVariable.isGreaterThan(0) || p.borrowedAmountStable.isGreaterThan(0)
+      );
+      if (!hasSupplyPositions && !hasBorrowPositions) {
+        return { text: `\u{1F4BC} **Your Aave V3 Position**
+
+\u{1F3E6} **No active positions found**
+
+You don't have any supplies or borrows on Aave V3 yet.
+Ready to start your DeFi journey? Try:
+\u2022 "supply 1000 USDC" to start earning yield
+\u2022 Check current "market rates" for opportunities` };
+      }
+      let positionSummary = `\u{1F4BC} **Your Aave V3 Position**
+
+`;
+      const shortAddress = `${userAddress.slice(0, 6)}...${userAddress.slice(-4)}`;
+      positionSummary += `\u{1F464} **Address**: ${shortAddress}
+
+`;
+      positionSummary += `\u{1F3E5} **Health Overview:**
+`;
+      positionSummary += `\u2022 Health Factor: ${position.healthFactor.isFinite() ? position.healthFactor.toFixed(3) : "\u221E"}
+`;
+      positionSummary += `\u2022 Total Collateral: $${position.totalCollateralETH.toFixed(2)}
+`;
+      positionSummary += `\u2022 Total Debt: $${position.totalDebtETH.toFixed(2)}
+`;
+      if (position.totalDebtETH.isGreaterThan(0)) {
+        positionSummary += `\u2022 Available to Borrow: $${position.availableBorrowsETH.toFixed(2)}
+`;
+        positionSummary += `\u2022 LTV Ratio: ${(position.ltv * 100).toFixed(1)}%
+`;
+      }
+      positionSummary += `
+`;
+      if (position.healthFactor.isFinite() && position.healthFactor.isLessThan(1.5)) {
+        positionSummary += `\u26A0\uFE0F  **HEALTH FACTOR WARNING**
+`;
+        if (position.healthFactor.isLessThan(1.1)) {
+          positionSummary += `\u{1F6A8} **CRITICAL**: Your position is near liquidation!
+`;
+        } else {
+          positionSummary += `\u26A1 **CAUTION**: Consider adding collateral or reducing debt
+`;
+        }
+        positionSummary += `
+`;
+      }
+      const supplies = position.positions.filter((p) => p.suppliedAmount.isGreaterThan(0));
+      if (supplies.length > 0) {
+        positionSummary += `\u{1F4B0} **Supply Positions:**
+`;
+        positionSummary += `\`\`\`
+`;
+        positionSummary += `Asset    Amount     APY    Collateral
+`;
+        positionSummary += `\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`;
+        for (const supply of supplies) {
+          const asset = supply.asset.padEnd(6);
+          const amount = formatNumber(supply.suppliedAmount).padStart(10);
+          const apy = `${supply.supplyAPY.toFixed(2)}%`.padStart(6);
+          const collateral = (supply.isCollateral ? "\u2705" : "\u274C").padStart(10);
+          positionSummary += `${asset}  ${amount}  ${apy}  ${collateral}
+`;
+        }
+        positionSummary += `\`\`\`
+
+`;
+      }
+      const borrows = position.positions.filter(
+        (p) => p.borrowedAmountVariable.isGreaterThan(0) || p.borrowedAmountStable.isGreaterThan(0)
+      );
+      if (borrows.length > 0) {
+        positionSummary += `\u{1F4B8} **Borrow Positions:**
+`;
+        positionSummary += `\`\`\`
+`;
+        positionSummary += `Asset    Amount     APY    Type
+`;
+        positionSummary += `\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+`;
+        for (const borrow of borrows) {
+          if (borrow.borrowedAmountVariable.isGreaterThan(0)) {
+            const asset = borrow.asset.padEnd(6);
+            const amount = formatNumber(borrow.borrowedAmountVariable).padStart(10);
+            const apy = `${borrow.variableBorrowAPY.toFixed(2)}%`.padStart(6);
+            const type = "Variable".padStart(8);
+            positionSummary += `${asset}  ${amount}  ${apy}  ${type}
+`;
+          }
+          if (borrow.borrowedAmountStable.isGreaterThan(0)) {
+            const asset = borrow.asset.padEnd(6);
+            const amount = formatNumber(borrow.borrowedAmountStable).padStart(10);
+            const apy = `${borrow.stableBorrowAPY.toFixed(2)}%`.padStart(6);
+            const type = "Stable".padStart(8);
+            positionSummary += `${asset}  ${amount}  ${apy}  ${type}
+`;
+          }
+        }
+        positionSummary += `\`\`\`
+
+`;
+      }
+      positionSummary += `\u{1F4A1} **Position Insights:**
+`;
+      if (hasSupplyPositions && !hasBorrowPositions) {
+        positionSummary += `\u2022 You're earning yield as a pure lender \u{1F3E6}
+`;
+        positionSummary += `\u2022 Consider borrowing stablecoins for leverage or other opportunities
+`;
+      } else if (hasBorrowPositions) {
+        if (position.healthFactor.isGreaterThan(2)) {
+          positionSummary += `\u2022 Healthy leveraged position \u{1F4AA}
+`;
+          positionSummary += `\u2022 You have room to borrow more if needed
+`;
+        } else if (position.healthFactor.isGreaterThan(1.5)) {
+          positionSummary += `\u2022 Moderate risk leveraged position \u2696\uFE0F
+`;
+          positionSummary += `\u2022 Monitor health factor closely
+`;
+        }
+      }
+      const nonCollateralAssets = supplies.filter((s) => !s.isCollateral);
+      if (nonCollateralAssets.length > 0) {
+        positionSummary += `\u2022 Some assets not used as collateral - enable for more borrowing power
+`;
+      }
+      positionSummary += `
+\u{1F4C5} *Position updated: ${(/* @__PURE__ */ new Date()).toLocaleString()}*`;
+      return { text: positionSummary };
+    } catch (error) {
+      elizaLogger.error("Failed to get user position:", error);
+      return { text: "Unable to fetch your current position from Aave V3. Please try again later." };
+    }
+  }
+};
+function formatNumber(num) {
+  if (num.isGreaterThanOrEqualTo(1e6)) {
+    return `${num.dividedBy(1e6).toFixed(2)}M`;
+  } else if (num.isGreaterThanOrEqualTo(1e3)) {
+    return `${num.dividedBy(1e3).toFixed(1)}K`;
+  } else if (num.isGreaterThanOrEqualTo(1)) {
+    return num.toFixed(2);
+  } else {
+    return num.toFixed(4);
+  }
+}
+
+// src/index.ts
+var plugin = {
+  name: "aave",
+  description: "Aave V3 Protocol integration for lending and borrowing operations",
+  // Core services
+  services: [AaveService],
+  // User actions
+  actions: [supplyAction, withdrawAction, borrowAction, repayAction],
+  // Context providers
+  providers: [marketDataProvider, positionProvider],
+  // No evaluators for now
+  evaluators: []
+};
+var index_default = plugin;
+
+export { AAVE_CONSTANTS, AaveError, AaveErrorCode, AaveService, InterestRateMode, borrowAction, index_default as default, isAaveError, isValidInterestRateMode, marketDataProvider, plugin, positionProvider, repayAction, supplyAction, withdrawAction };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map