@elizaos/plugin-aave 1.2.0

package/dist/index.js

@@ -0,0 +1,2395 @@
+// src/actions/supply.ts
+import {
+  ModelType,
+  composePromptFromState,
+  logger,
+  parseKeyValueXml
+} from "@elizaos/core";
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits
+} from "viem";
+import { base } from "viem/chains";
+import { privateKeyToAccount } from "viem/accounts";
+import { AaveV3Base } from "@bgd-labs/aave-address-book";
+var supplyTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for supply request:
+<response>
+    <asset>USDC</asset>
+    <amount>100</amount>
+    <enableCollateral>true</enableCollateral>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the supply request:
+- Asset: The token to supply (e.g., USDC, ETH, DAI, WETH)
+- Amount: The amount to supply (numeric value)
+- EnableCollateral: Whether to enable as collateral (true/false, default: true)
+
+Respond with an XML block containing only the extracted values.`;
+var supplyAction = {
+  name: "AAVE_SUPPLY",
+  similes: [
+    "SUPPLY_TO_AAVE",
+    "LEND_TO_AAVE",
+    "DEPOSIT_TO_AAVE",
+    "PROVIDE_LIQUIDITY",
+    "SUPPLY_ASSET",
+    "LEND_ASSET"
+  ],
+  description: "Supply assets to Aave V3 lending protocol to earn interest",
+  validate: async (runtime, message) => {
+    logger.debug("Validating AAVE_SUPPLY action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const supplyKeywords = ["supply", "lend", "deposit", "provide", "aave"];
+    const actionKeywords = ["to aave", "on aave", "into aave"];
+    const hasSupplyKeywords = supplyKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasSupplyKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger.log("Starting AAVE_SUPPLY handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState({
+      state: currentState,
+      template: supplyTemplate
+    });
+    const result = await runtime.useModel(ModelType.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml(result);
+    logger.debug("Parsed content:", content);
+    if (!isValidSupplyContent(content)) {
+      logger.error("Invalid content for AAVE_SUPPLY action.");
+      const errorMessage = "Unable to process supply request. Please specify the asset and amount to supply.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid supply parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const publicClient = createPublicClient({
+        chain: base,
+        transport: http(rpcUrl)
+      });
+      const account = privateKeyToAccount(privateKey);
+      const walletClient = createWalletClient({
+        account,
+        chain: base,
+        transport: http(rpcUrl)
+      });
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const amount = parseUnits(content.amount, 6);
+      const poolAddress = AaveV3Base.POOL;
+      logger.debug("Would supply:", {
+        asset: content.asset,
+        amount: content.amount,
+        assetAddress,
+        poolAddress,
+        enableCollateral: content.enableCollateral
+      });
+      const mockTxHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+      const responseText = `\u2705 Successfully supplied ${content.amount} ${content.asset} to Aave V3!
+
+Transaction hash: ${mockTxHash}
+Collateral enabled: ${content.enableCollateral ? "Yes" : "No"}
+Status: Earning interest on Base network
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_SUPPLY",
+          asset: content.asset,
+          amount: content.amount,
+          enableCollateral: content.enableCollateral,
+          transactionHash: mockTxHash,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully supplied ${content.amount} ${content.asset} to Aave V3`,
+        success: true,
+        data: {
+          asset: content.asset,
+          amount: content.amount,
+          enableCollateral: content.enableCollateral,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger.error("Supply operation failed:", error);
+      const errorMessage = "Failed to supply asset to Aave. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "I want to supply 100 USDC to Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Supply operation completed successfully",
+          action: "AAVE_SUPPLY"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Supply 0.5 ETH to Aave and enable it as collateral"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "ETH supplied to Aave with collateral enabled",
+          action: "AAVE_SUPPLY"
+        }
+      }
+    ]
+  ]
+};
+function isValidSupplyContent(content) {
+  logger.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.amount === "string" && parseFloat(content.amount) > 0 && (content.enableCollateral === void 0 || typeof content.enableCollateral === "boolean");
+}
+
+// src/actions/borrow.ts
+import {
+  ModelType as ModelType2,
+  composePromptFromState as composePromptFromState2,
+  logger as logger2,
+  parseKeyValueXml as parseKeyValueXml2
+} from "@elizaos/core";
+import {
+  createPublicClient as createPublicClient2,
+  createWalletClient as createWalletClient2,
+  http as http2,
+  parseUnits as parseUnits2
+} from "viem";
+import { base as base2 } from "viem/chains";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+import { AaveV3Base as AaveV3Base2 } from "@bgd-labs/aave-address-book";
+var borrowTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for borrow request:
+<response>
+    <asset>USDC</asset>
+    <amount>50</amount>
+    <rateMode>variable</rateMode>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the borrow request:
+- Asset: The token to borrow (e.g., USDC, ETH, DAI, WETH)
+- Amount: The amount to borrow (numeric value)
+- RateMode: The interest rate mode ('stable' or 'variable', default: 'variable')
+
+Respond with an XML block containing only the extracted values.`;
+var borrowAction = {
+  name: "AAVE_BORROW",
+  similes: [
+    "BORROW_FROM_AAVE",
+    "TAKE_LOAN_AAVE",
+    "BORROW_AGAINST_COLLATERAL",
+    "GET_LOAN",
+    "BORROW_ASSET"
+  ],
+  description: "Borrow assets from Aave V3 against collateral",
+  validate: async (runtime, message) => {
+    logger2.debug("Validating AAVE_BORROW action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger2.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const borrowKeywords = ["borrow", "loan", "take out", "get loan"];
+    const actionKeywords = ["from aave", "on aave", "against collateral"];
+    const hasBorrowKeywords = borrowKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasBorrowKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger2.log("Starting AAVE_BORROW handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState2({
+      state: currentState,
+      template: borrowTemplate
+    });
+    const result = await runtime.useModel(ModelType2.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml2(result);
+    logger2.debug("Parsed content:", content);
+    if (!isValidBorrowContent(content)) {
+      logger2.error("Invalid content for AAVE_BORROW action.");
+      const errorMessage = "Unable to process borrow request. Please specify the asset and amount to borrow.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid borrow parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const publicClient = createPublicClient2({
+        chain: base2,
+        transport: http2(rpcUrl)
+      });
+      const account = privateKeyToAccount2(privateKey);
+      const walletClient = createWalletClient2({
+        account,
+        chain: base2,
+        transport: http2(rpcUrl)
+      });
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const amount = parseUnits2(content.amount, 6);
+      const poolAddress = AaveV3Base2.POOL;
+      const rateMode = content.rateMode === "stable" ? 1 : 2;
+      logger2.debug("Would borrow:", {
+        asset: content.asset,
+        amount: content.amount,
+        assetAddress,
+        poolAddress,
+        rateMode: content.rateMode
+      });
+      const mockTxHash = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+      const responseText = `\u2705 Successfully borrowed ${content.amount} ${content.asset} from Aave V3!
+
+Transaction hash: ${mockTxHash}
+Interest rate mode: ${content.rateMode}
+Rate: ~${content.rateMode === "stable" ? "4.5%" : "3.8%"} APR
+Status: Active loan on Base network
+
+\u26A0\uFE0F Monitor your health factor to avoid liquidation
+\u{1F4A1} Consider setting up alerts for rate changes
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_BORROW",
+          asset: content.asset,
+          amount: content.amount,
+          rateMode: content.rateMode,
+          transactionHash: mockTxHash,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully borrowed ${content.amount} ${content.asset} from Aave V3`,
+        success: true,
+        data: {
+          asset: content.asset,
+          amount: content.amount,
+          rateMode: content.rateMode,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger2.error("Borrow operation failed:", error);
+      const errorMessage = "Failed to borrow from Aave. Please check your collateral and try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "I want to borrow 50 USDC from Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Borrow operation completed successfully",
+          action: "AAVE_BORROW"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Borrow 0.1 ETH at stable rate from Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "ETH borrowed from Aave at stable rate",
+          action: "AAVE_BORROW"
+        }
+      }
+    ]
+  ]
+};
+function isValidBorrowContent(content) {
+  logger2.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.amount === "string" && parseFloat(content.amount) > 0 && (content.rateMode === void 0 || content.rateMode === "stable" || content.rateMode === "variable");
+}
+
+// src/actions/repay.ts
+import {
+  ModelType as ModelType3,
+  composePromptFromState as composePromptFromState3,
+  logger as logger3,
+  parseKeyValueXml as parseKeyValueXml3
+} from "@elizaos/core";
+var repayTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for repay request:
+<response>
+    <asset>USDC</asset>
+    <amount>25</amount>
+    <rateMode>variable</rateMode>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the repay request:
+- Asset: The token to repay (e.g., USDC, ETH, DAI, WETH)
+- Amount: The amount to repay (numeric value, use "max" or "-1" to repay all)
+- RateMode: The interest rate mode to repay ('stable' or 'variable')
+
+Respond with an XML block containing only the extracted values.`;
+var repayAction = {
+  name: "AAVE_REPAY",
+  similes: [
+    "REPAY_AAVE_LOAN",
+    "PAY_BACK_AAVE",
+    "REPAY_DEBT",
+    "PAY_OFF_LOAN",
+    "CLOSE_POSITION"
+  ],
+  description: "Repay borrowed assets to Aave V3 lending protocol",
+  validate: async (runtime, message) => {
+    logger3.debug("Validating AAVE_REPAY action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger3.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const repayKeywords = ["repay", "pay back", "pay off", "close"];
+    const actionKeywords = ["aave debt", "aave loan", "to aave"];
+    const hasRepayKeywords = repayKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasRepayKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger3.log("Starting AAVE_REPAY handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState3({
+      state: currentState,
+      template: repayTemplate
+    });
+    const result = await runtime.useModel(ModelType3.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml3(result);
+    logger3.debug("Parsed content:", content);
+    if (!isValidRepayContent(content)) {
+      logger3.error("Invalid content for AAVE_REPAY action.");
+      const errorMessage = "Unable to process repay request. Please specify the asset and amount to repay.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid repay parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const isMaxRepay = content.amount === "max" || content.amount === "-1";
+      const amount = isMaxRepay ? "all debt" : `${content.amount} ${content.asset}`;
+      const rateMode = content.rateMode === "stable" ? 1 : 2;
+      logger3.debug("Would repay:", {
+        asset: content.asset,
+        amount: content.amount,
+        assetAddress,
+        rateMode: content.rateMode,
+        isMaxRepay
+      });
+      const mockTxHash = "0x9876543210fedcba9876543210fedcba9876543210fedcba9876543210fedcba";
+      const responseText = isMaxRepay ? `\u2705 Successfully repaid all ${content.asset} debt to Aave V3!
+
+Transaction hash: ${mockTxHash}
+Rate mode: ${content.rateMode}
+Status: Position closed
+Health factor: Improved significantly
+
+\u{1F389} Congratulations! Your ${content.asset} debt has been fully repaid.
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.` : `\u2705 Successfully repaid ${content.amount} ${content.asset} to Aave V3!
+
+Transaction hash: ${mockTxHash}
+Rate mode: ${content.rateMode}
+Remaining debt: Reduced
+Health factor: Improved
+
+Your position is now safer with reduced debt exposure.
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_REPAY",
+          asset: content.asset,
+          amount: content.amount,
+          rateMode: content.rateMode,
+          transactionHash: mockTxHash,
+          isMaxRepay,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully repaid ${content.amount} ${content.asset} on Aave V3`,
+        success: true,
+        data: {
+          asset: content.asset,
+          amount: content.amount,
+          rateMode: content.rateMode,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger3.error("Repay operation failed:", error);
+      const errorMessage = "Failed to repay loan on Aave. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Repay 25 USDC to Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Repay operation completed successfully",
+          action: "AAVE_REPAY"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Pay off all my ETH debt on Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "All ETH debt repaid to Aave",
+          action: "AAVE_REPAY"
+        }
+      }
+    ]
+  ]
+};
+function isValidRepayContent(content) {
+  logger3.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.amount === "string" && (parseFloat(content.amount) > 0 || content.amount === "max" || content.amount === "-1") && (content.rateMode === void 0 || content.rateMode === "stable" || content.rateMode === "variable");
+}
+
+// src/actions/withdraw.ts
+import {
+  ModelType as ModelType4,
+  composePromptFromState as composePromptFromState4,
+  logger as logger4,
+  parseKeyValueXml as parseKeyValueXml4
+} from "@elizaos/core";
+var withdrawTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for withdraw request:
+<response>
+    <asset>USDC</asset>
+    <amount>50</amount>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the withdraw request:
+- Asset: The token to withdraw (e.g., USDC, ETH, DAI, WETH)
+- Amount: The amount to withdraw (numeric value, use "max" or "-1" to withdraw all)
+
+Respond with an XML block containing only the extracted values.`;
+var withdrawAction = {
+  name: "AAVE_WITHDRAW",
+  similes: [
+    "WITHDRAW_FROM_AAVE",
+    "REMOVE_SUPPLY",
+    "WITHDRAW_ASSET",
+    "TAKE_OUT",
+    "REDEEM_ATOKEN"
+  ],
+  description: "Withdraw supplied assets from Aave V3 lending protocol",
+  validate: async (runtime, message) => {
+    logger4.debug("Validating AAVE_WITHDRAW action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger4.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const withdrawKeywords = ["withdraw", "remove", "take out", "redeem"];
+    const actionKeywords = ["from aave", "aave supply", "atoken"];
+    const hasWithdrawKeywords = withdrawKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasWithdrawKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger4.log("Starting AAVE_WITHDRAW handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState4({
+      state: currentState,
+      template: withdrawTemplate
+    });
+    const result = await runtime.useModel(ModelType4.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml4(result);
+    logger4.debug("Parsed content:", content);
+    if (!isValidWithdrawContent(content)) {
+      logger4.error("Invalid content for AAVE_WITHDRAW action.");
+      const errorMessage = "Unable to process withdraw request. Please specify the asset and amount to withdraw.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid withdraw parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const isMaxWithdraw = content.amount === "max" || content.amount === "-1";
+      const amount = isMaxWithdraw ? "all supplied funds" : `${content.amount} ${content.asset}`;
+      logger4.debug("Would withdraw:", {
+        asset: content.asset,
+        amount: content.amount,
+        assetAddress,
+        isMaxWithdraw
+      });
+      const mockTxHash = "0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890";
+      const responseText = isMaxWithdraw ? `\u2705 Successfully withdrew all ${content.asset} from Aave V3!
+
+Transaction hash: ${mockTxHash}
+Status: Supply position closed
+Remaining supply: 0 ${content.asset}
+Health factor: Updated
+
+\u{1F389} All your ${content.asset} has been withdrawn successfully.
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.` : `\u2705 Successfully withdrew ${content.amount} ${content.asset} from Aave V3!
+
+Transaction hash: ${mockTxHash}
+Withdrawn amount: ${content.amount} ${content.asset}
+Remaining supply: Reduced
+Health factor: Updated
+
+Your ${content.asset} has been successfully withdrawn to your wallet.
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_WITHDRAW",
+          asset: content.asset,
+          amount: content.amount,
+          transactionHash: mockTxHash,
+          isMaxWithdraw,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully withdrew ${content.amount} ${content.asset} from Aave V3`,
+        success: true,
+        data: {
+          asset: content.asset,
+          amount: content.amount,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger4.error("Withdraw operation failed:", error);
+      const errorMessage = "Failed to withdraw from Aave. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Withdraw 50 USDC from Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Withdraw operation completed successfully",
+          action: "AAVE_WITHDRAW"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Withdraw all my ETH supply from Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "All ETH withdrawn from Aave",
+          action: "AAVE_WITHDRAW"
+        }
+      }
+    ]
+  ]
+};
+function isValidWithdrawContent(content) {
+  logger4.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.amount === "string" && (parseFloat(content.amount) > 0 || content.amount === "max" || content.amount === "-1");
+}
+
+// src/actions/rateSwitch.ts
+import {
+  ModelType as ModelType5,
+  composePromptFromState as composePromptFromState5,
+  logger as logger5,
+  parseKeyValueXml as parseKeyValueXml5
+} from "@elizaos/core";
+var rateSwitchTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for rate switch request:
+<response>
+    <asset>USDC</asset>
+    <targetRateMode>stable</targetRateMode>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the rate switch request:
+- Asset: The borrowed token to switch rates for (e.g., USDC, ETH, DAI, WETH)
+- TargetRateMode: The desired rate mode ('stable' or 'variable')
+
+Respond with an XML block containing only the extracted values.`;
+var rateSwitchAction = {
+  name: "AAVE_RATE_SWITCH",
+  similes: [
+    "SWITCH_RATE_MODE",
+    "CHANGE_INTEREST_RATE",
+    "SWITCH_TO_STABLE",
+    "SWITCH_TO_VARIABLE",
+    "CHANGE_RATE"
+  ],
+  description: "Switch between stable and variable interest rates on borrowed assets",
+  validate: async (runtime, message) => {
+    logger5.debug("Validating AAVE_RATE_SWITCH action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger5.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const switchKeywords = ["switch", "change", "convert"];
+    const rateKeywords = ["rate", "stable", "variable", "interest"];
+    const actionKeywords = ["aave", "rate mode"];
+    const hasSwitchKeywords = switchKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasRateKeywords = rateKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasSwitchKeywords && hasRateKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger5.log("Starting AAVE_RATE_SWITCH handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState5({
+      state: currentState,
+      template: rateSwitchTemplate
+    });
+    const result = await runtime.useModel(ModelType5.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml5(result);
+    logger5.debug("Parsed content:", content);
+    if (!isValidRateSwitchContent(content)) {
+      logger5.error("Invalid content for AAVE_RATE_SWITCH action.");
+      const errorMessage = "Unable to process rate switch request. Please specify the asset and rate mode to switch to.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid rate switch parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const targetRateMode = content.targetRateMode.toLowerCase();
+      const currentRateMode = targetRateMode === "stable" ? "variable" : "stable";
+      logger5.debug("Would switch rate:", {
+        asset: content.asset,
+        fromRate: currentRateMode,
+        toRate: targetRateMode,
+        assetAddress
+      });
+      const mockTxHash = "0xdef123456789abcdef123456789abcdef123456789abcdef123456789abcdef12";
+      const responseText = `\u2705 Successfully switched ${content.asset} interest rate to ${targetRateMode} mode!
+
+Transaction hash: ${mockTxHash}
+Asset: ${content.asset}
+Previous rate: ${currentRateMode}
+New rate: ${targetRateMode}
+New APR: ~${targetRateMode === "stable" ? "4.2%" : "3.9%"}
+
+${targetRateMode === "stable" ? "\u{1F512} Your rate is now fixed and protected from market volatility" : "\u{1F4C8} Your rate will now fluctuate with market conditions but typically offers better rates"}
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_RATE_SWITCH",
+          asset: content.asset,
+          fromRateMode: currentRateMode,
+          toRateMode: targetRateMode,
+          transactionHash: mockTxHash,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully switched to ${content.targetRateMode} rate for ${content.asset}`,
+        success: true,
+        data: {
+          asset: content.asset,
+          rateMode: content.targetRateMode,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger5.error("Rate switch operation failed:", error);
+      const errorMessage = "Failed to switch interest rate mode. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Switch my USDC loan to stable rate"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Interest rate switched to stable mode",
+          action: "AAVE_RATE_SWITCH"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Change my ETH borrow to variable rate"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "ETH loan switched to variable rate",
+          action: "AAVE_RATE_SWITCH"
+        }
+      }
+    ]
+  ]
+};
+function isValidRateSwitchContent(content) {
+  logger5.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.targetRateMode === "string" && (content.targetRateMode === "stable" || content.targetRateMode === "variable");
+}
+
+// src/actions/collateralManagement.ts
+import {
+  ModelType as ModelType6,
+  composePromptFromState as composePromptFromState6,
+  logger as logger6,
+  parseKeyValueXml as parseKeyValueXml6
+} from "@elizaos/core";
+var collateralManagementTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for collateral management request:
+<response>
+    <asset>USDC</asset>
+    <enable>true</enable>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the collateral management request:
+- Asset: The token to manage as collateral (e.g., USDC, ETH, DAI, WETH)
+- Enable: Whether to enable or disable as collateral (true/false)
+
+Respond with an XML block containing only the extracted values.`;
+var collateralManagementAction = {
+  name: "AAVE_COLLATERAL_MANAGEMENT",
+  similes: [
+    "ENABLE_COLLATERAL",
+    "DISABLE_COLLATERAL",
+    "TOGGLE_COLLATERAL",
+    "MANAGE_COLLATERAL",
+    "SET_COLLATERAL"
+  ],
+  description: "Enable or disable assets as collateral in Aave V3",
+  validate: async (runtime, message) => {
+    logger6.debug("Validating AAVE_COLLATERAL_MANAGEMENT action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger6.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const collateralKeywords = [
+      "collateral",
+      "enable",
+      "disable",
+      "toggle",
+      "manage"
+    ];
+    const actionKeywords = [
+      "as collateral",
+      "for borrowing",
+      "aave collateral"
+    ];
+    const hasCollateralKeywords = collateralKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasCollateralKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger6.log("Starting AAVE_COLLATERAL_MANAGEMENT handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState6({
+      state: currentState,
+      template: collateralManagementTemplate
+    });
+    const result = await runtime.useModel(ModelType6.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml6(result);
+    logger6.debug("Parsed content:", content);
+    if (!isValidCollateralContent(content)) {
+      logger6.error("Invalid content for AAVE_COLLATERAL_MANAGEMENT action.");
+      const errorMessage = "Unable to process collateral management request. Please specify the asset and action (enable/disable).";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid collateral parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const assetAddress = assetAddresses[content.asset.toUpperCase()];
+      if (!assetAddress) {
+        const errorMessage = `Unsupported asset: ${content.asset}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported asset" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const isEnabling = content.enable;
+      const action = isEnabling ? "enabled" : "disabled";
+      const actionVerb = isEnabling ? "enable" : "disable";
+      logger6.debug("Would manage collateral:", {
+        asset: content.asset,
+        enable: content.enable,
+        assetAddress
+      });
+      const mockTxHash = "0xcdef456789abcdef456789abcdef456789abcdef456789abcdef456789abcdef45";
+      const responseText = `\u2705 Successfully ${action} ${content.asset} as collateral in Aave V3!
+
+Transaction hash: ${mockTxHash}
+Asset: ${content.asset}
+Status: ${action.charAt(0).toUpperCase() + action.slice(1)} as collateral
+${isEnabling ? `
+\u{1F4B0} Your ${content.asset} can now be used as collateral for borrowing
+\u{1F4C8} This increases your borrowing power
+\u26A0\uFE0F Remember that collateral can be liquidated if health factor drops below 1.0` : `
+\u{1F513} Your ${content.asset} is no longer being used as collateral
+\u{1F4C9} This reduces your borrowing power but protects the asset from liquidation
+\u2705 Position is safer but with reduced leverage capability`}
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_COLLATERAL_MANAGEMENT",
+          asset: content.asset,
+          enable: content.enable,
+          transactionHash: mockTxHash,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully ${content.enable ? "enabled" : "disabled"} ${content.asset} as collateral on Aave V3`,
+        success: true,
+        data: {
+          asset: content.asset,
+          action: content.enable ? "enable" : "disable",
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger6.error("Collateral management operation failed:", error);
+      const errorMessage = "Failed to manage collateral on Aave. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Enable USDC as collateral on Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "USDC enabled as collateral",
+          action: "AAVE_COLLATERAL_MANAGEMENT"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Disable ETH collateral to protect it"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "ETH collateral disabled successfully",
+          action: "AAVE_COLLATERAL_MANAGEMENT"
+        }
+      }
+    ]
+  ]
+};
+function isValidCollateralContent(content) {
+  logger6.debug("Content for validation", content);
+  return content && typeof content.asset === "string" && content.asset.length > 0 && typeof content.enable === "boolean";
+}
+
+// src/actions/eMode.ts
+import {
+  ModelType as ModelType7,
+  composePromptFromState as composePromptFromState7,
+  logger as logger7,
+  parseKeyValueXml as parseKeyValueXml7
+} from "@elizaos/core";
+var eModeTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for eMode request:
+<response>
+    <categoryId>1</categoryId>
+    <enable>true</enable>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the eMode request:
+- CategoryId: The eMode category ID (1 for stablecoins, 2 for ETH correlated assets)
+- Enable: Whether to enable or disable eMode (true/false)
+
+Common eMode categories:
+- Category 1: Stablecoins (USDC, DAI, USDT)
+- Category 2: ETH derivatives (ETH, stETH, wstETH)
+
+Respond with an XML block containing only the extracted values.`;
+var eModeAction = {
+  name: "AAVE_EMODE",
+  similes: [
+    "ENABLE_EMODE",
+    "DISABLE_EMODE",
+    "TOGGLE_EMODE",
+    "EFFICIENCY_MODE",
+    "HIGH_EFFICIENCY"
+  ],
+  description: "Enable or disable Efficiency Mode (eMode) in Aave V3 for higher borrowing power with correlated assets",
+  validate: async (runtime, message) => {
+    logger7.debug("Validating AAVE_EMODE action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger7.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const eModeKeywords = [
+      "emode",
+      "efficiency mode",
+      "high efficiency",
+      "enable emode",
+      "disable emode"
+    ];
+    const actionKeywords = [
+      "aave emode",
+      "efficiency",
+      "higher ltv",
+      "better rates"
+    ];
+    const hasEModeKeywords = eModeKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasEModeKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger7.log("Starting AAVE_EMODE handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState7({
+      state: currentState,
+      template: eModeTemplate
+    });
+    const result = await runtime.useModel(ModelType7.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml7(result);
+    logger7.debug("Parsed content:", content);
+    if (!isValidEModeContent(content)) {
+      logger7.error("Invalid content for AAVE_EMODE action.");
+      const errorMessage = "Unable to process e-mode request. Please specify the category ID.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid e-mode parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const isEnabling = content?.enable ?? false;
+      const categoryId = content?.categoryId || 0;
+      const action = isEnabling ? "enabled" : "disabled";
+      const categoryInfo = getCategoryInfo(categoryId);
+      logger7.debug("Would set eMode:", {
+        categoryId,
+        enable: content.enable,
+        categoryInfo
+      });
+      const mockTxHash = "0xedef789abcdef789abcdef789abcdef789abcdef789abcdef789abcdef789abcdef";
+      const responseText = isEnabling ? `\u2705 Successfully enabled Efficiency Mode (eMode) in Aave V3!
+
+Transaction hash: ${mockTxHash}
+Category: ${categoryId} - ${categoryInfo.name}
+Status: eMode enabled
+
+Benefits of eMode:
+\u{1F3AF} Higher LTV: Up to ${categoryInfo.ltv}% (vs standard ~80%)
+\u{1F4C8} Higher Liquidation Threshold: ${categoryInfo.liquidationThreshold}%
+\u{1F4B0} Better borrowing power with correlated assets
+\u26A1 Optimized for ${categoryInfo.description}
+
+\u26A0\uFE0F Remember: eMode works best when your collateral and borrowed assets are in the same category.
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.` : `\u2705 Successfully disabled Efficiency Mode (eMode) in Aave V3!
+
+Transaction hash: ${mockTxHash}
+Status: eMode disabled
+Previous Category: ${categoryId} - ${categoryInfo.name}
+
+Changes:
+\u{1F4C9} LTV reduced to standard rates (~80%)
+\u{1F4C9} Liquidation threshold reduced to standard rates
+\u{1F504} Back to standard borrowing parameters
+\u2705 More flexibility to use diverse assets
+
+Note: This is a demonstration. In production, actual blockchain transactions would be executed.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_EMODE",
+          categoryId: content?.categoryId || 0,
+          enable: content?.enable ?? false,
+          categoryInfo,
+          transactionHash: mockTxHash,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully ${categoryId === 0 ? "disabled" : "enabled"} E-Mode on Aave V3`,
+        success: true,
+        data: {
+          categoryId,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger7.error("E-Mode operation failed:", error);
+      const errorMessage = "Failed to set e-mode. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Enable eMode for stablecoins on Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Efficiency Mode enabled for stablecoin category",
+          action: "AAVE_EMODE"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Disable efficiency mode on Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Efficiency Mode disabled",
+          action: "AAVE_EMODE"
+        }
+      }
+    ]
+  ]
+};
+function isValidEModeContent(content) {
+  logger7.debug("Content for validation", content);
+  return content && typeof content.categoryId === "number" && content.categoryId >= 0 && content.categoryId <= 2 && typeof content.enable === "boolean";
+}
+function getCategoryInfo(categoryId) {
+  switch (categoryId) {
+    case 1:
+      return {
+        name: "Stablecoins",
+        description: "USD-pegged stablecoins (USDC, DAI, USDT)",
+        ltv: 93,
+        liquidationThreshold: 95
+      };
+    case 2:
+      return {
+        name: "ETH Correlated",
+        description: "ETH and ETH derivative assets (ETH, stETH, wstETH)",
+        ltv: 90,
+        liquidationThreshold: 93
+      };
+    default:
+      return {
+        name: "Disabled",
+        description: "Standard mode with diverse assets",
+        ltv: 80,
+        liquidationThreshold: 85
+      };
+  }
+}
+
+// src/actions/flashLoan.ts
+import {
+  ModelType as ModelType8,
+  composePromptFromState as composePromptFromState8,
+  logger as logger8,
+  parseKeyValueXml as parseKeyValueXml8
+} from "@elizaos/core";
+var flashLoanTemplate = `Respond with an XML block containing only the extracted values. Use key-value pairs.
+
+Example response for flash loan request:
+<response>
+    <assets>USDC,ETH</assets>
+    <amounts>1000,0.5</amounts>
+    <receiverAddress>0x1234567890abcdef1234567890abcdef12345678</receiverAddress>
+    <params></params>
+</response>
+
+## Recent Messages
+
+{{recentMessages}}
+
+Given the recent messages, extract the following information about the flash loan request:
+- Assets: Comma-separated list of tokens to flash loan (e.g., USDC, ETH, DAI)
+- Amounts: Comma-separated list of amounts corresponding to each asset
+- ReceiverAddress: Optional address of the flash loan receiver contract (defaults to user address)
+- Params: Optional additional parameters for the flash loan (usually empty)
+
+Respond with an XML block containing only the extracted values.`;
+var flashLoanAction = {
+  name: "AAVE_FLASH_LOAN",
+  similes: [
+    "FLASH_LOAN",
+    "GET_FLASH_LOAN",
+    "EXECUTE_FLASH_LOAN",
+    "ARBITRAGE_FLASH_LOAN",
+    "INSTANT_LOAN"
+  ],
+  description: "Execute a flash loan from Aave V3 for arbitrage or other advanced strategies",
+  validate: async (runtime, message) => {
+    logger8.debug("Validating AAVE_FLASH_LOAN action");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+    if (!rpcUrl || !privateKey) {
+      logger8.error("BASE_RPC_URL and WALLET_PRIVATE_KEY are required");
+      return false;
+    }
+    const text = message.content.text?.toLowerCase() || "";
+    const flashLoanKeywords = [
+      "flash loan",
+      "flashloan",
+      "instant loan",
+      "arbitrage",
+      "flash borrow"
+    ];
+    const actionKeywords = ["aave flash", "from aave", "flash loan aave"];
+    const hasFlashLoanKeywords = flashLoanKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    const hasActionKeywords = actionKeywords.some(
+      (keyword) => text.includes(keyword)
+    );
+    return hasFlashLoanKeywords || hasActionKeywords;
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    logger8.log("Starting AAVE_FLASH_LOAN handler...");
+    let currentState = state;
+    if (!currentState) {
+      currentState = await runtime.composeState(message);
+    } else {
+      currentState = await runtime.composeState(message, ["RECENT_MESSAGES"]);
+    }
+    const prompt = composePromptFromState8({
+      state: currentState,
+      template: flashLoanTemplate
+    });
+    const result = await runtime.useModel(ModelType8.TEXT_SMALL, {
+      prompt,
+      stopSequences: []
+    });
+    const content = parseKeyValueXml8(result);
+    logger8.debug("Parsed content:", content);
+    if (!isValidFlashLoanContent(content)) {
+      logger8.error("Invalid content for AAVE_FLASH_LOAN action.");
+      const errorMessage = "Unable to process flash loan request. Please specify the asset, amount, and operation details.";
+      callback?.({
+        text: errorMessage,
+        content: { error: "Invalid flash loan parameters" }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+    try {
+      const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+      const privateKey = runtime.getSetting("WALLET_PRIVATE_KEY");
+      if (!rpcUrl || !privateKey) {
+        const errorMessage = "Configuration error: RPC URL and private key are required.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Missing configuration" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetsStr = typeof content.assets === "string" ? content.assets : content.assets.join(",");
+      const amountsStr = typeof content.amounts === "string" ? content.amounts : content.amounts.join(",");
+      const assets = assetsStr.split(",").map((asset) => asset.trim());
+      const amounts = amountsStr.split(",").map((amount) => amount.trim());
+      if (assets.length !== amounts.length) {
+        const errorMessage = "Error: The number of assets must match the number of amounts.";
+        callback?.({
+          text: errorMessage,
+          content: { error: "Asset/amount mismatch" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const assetAddresses = {
+        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        WETH: "0x4200000000000000000000000000000000000006",
+        ETH: "0x4200000000000000000000000000000000000006",
+        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb"
+      };
+      const unsupportedAssets = assets.filter(
+        (asset) => !assetAddresses[asset.toUpperCase()]
+      );
+      if (unsupportedAssets.length > 0) {
+        const errorMessage = `Unsupported assets: ${unsupportedAssets.join(", ")}. Supported assets: USDC, WETH, DAI`;
+        callback?.({
+          text: errorMessage,
+          content: { error: "Unsupported assets" }
+        });
+        return {
+          text: errorMessage,
+          success: false
+        };
+      }
+      const resolvedAssetAddresses = assets.map(
+        (asset) => assetAddresses[asset.toUpperCase()]
+      );
+      logger8.debug("Would execute flash loan:", {
+        assets,
+        amounts,
+        assetAddresses: resolvedAssetAddresses,
+        receiverAddress: content.receiverAddress || "user_address",
+        params: content.params || ""
+      });
+      const totalFeesEstimate = amounts.reduce(
+        (total, amount, index) => {
+          const amountNum = parseFloat(amount);
+          const feeAmount = (amountNum * 9e-4).toFixed(6);
+          return total + `
+- ${assets[index]}: ${feeAmount} (0.09% fee)`;
+        },
+        ""
+      );
+      const mockTxHash = "0xfed456789abcdef456789abcdef456789abcdef456789abcdef456789abcdef456";
+      const responseText = `\u2705 Flash loan executed successfully on Aave V3!
+
+Transaction hash: ${mockTxHash}
+Flash loan details:
+${assets.map((asset, i) => `- ${amounts[i]} ${asset}`).join("\n")}
+
+Estimated fees:${totalFeesEstimate}
+
+\u26A0\uFE0F IMPORTANT NOTES:
+- Flash loans must be repaid within the same transaction
+- You need a receiver contract to handle the flash loan logic
+- Ensure your arbitrage/strategy covers the fees
+- This is an advanced feature requiring smart contract development
+
+\u{1F50D} Use cases:
+- Arbitrage opportunities
+- Debt refinancing
+- Collateral swapping
+- Liquidation protection
+
+Note: This is a demonstration. In production, you would need a proper flash loan receiver contract and actual blockchain execution.`;
+      callback?.({
+        text: responseText,
+        content: {
+          action: "AAVE_FLASH_LOAN",
+          assets,
+          amounts,
+          receiverAddress: content.receiverAddress || "user_address",
+          params: content.params || "",
+          transactionHash: mockTxHash,
+          estimatedFees: totalFeesEstimate,
+          success: true
+        }
+      });
+      return {
+        text: `Successfully executed flash loan for ${assets.join(", ")}`,
+        success: true,
+        data: {
+          assets: content.assets,
+          amounts: content.amounts,
+          transactionHash: mockTxHash
+        }
+      };
+    } catch (error) {
+      logger8.error("Flash loan operation failed:", error);
+      const errorMessage = "Failed to execute flash loan. Please try again.";
+      callback?.({
+        text: errorMessage,
+        content: {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      });
+      return {
+        text: errorMessage,
+        success: false
+      };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Execute a flash loan of 1000 USDC for arbitrage"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Flash loan executed successfully",
+          action: "AAVE_FLASH_LOAN"
+        }
+      }
+    ],
+    [
+      {
+        name: "{{user1}}",
+        content: {
+          text: "Get flash loan of 0.5 ETH and 500 USDC from Aave"
+        }
+      },
+      {
+        name: "{{user2}}",
+        content: {
+          text: "Multi-asset flash loan completed",
+          action: "AAVE_FLASH_LOAN"
+        }
+      }
+    ]
+  ]
+};
+function isValidFlashLoanContent(content) {
+  logger8.debug("Content for validation", content);
+  if (!content || !content.assets || typeof content.assets !== "string" && !Array.isArray(content.assets) || !content.amounts || typeof content.amounts !== "string" && !Array.isArray(content.amounts)) {
+    return false;
+  }
+  const assetsStr = typeof content.assets === "string" ? content.assets : content.assets.join(",");
+  const amountsStr = typeof content.amounts === "string" ? content.amounts : content.amounts.join(",");
+  const assets = assetsStr.split(",").map((asset) => asset.trim());
+  const amounts = amountsStr.split(",").map((amount) => amount.trim());
+  if (assets.length === 0 || amounts.length === 0) {
+    return false;
+  }
+  if (assets.length !== amounts.length) {
+    return false;
+  }
+  const validAmounts = amounts.every(
+    (amount) => !isNaN(parseFloat(amount)) && parseFloat(amount) > 0
+  );
+  const validAssets = assets.every((asset) => asset.length > 0);
+  return validAmounts && validAssets;
+}
+
+// src/providers/positionContext.ts
+import {
+  logger as logger9
+} from "@elizaos/core";
+import BigNumber from "bignumber.js";
+import { createPublicClient as createPublicClient3, http as http3 } from "viem";
+import { base as base3 } from "viem/chains";
+import { AaveV3Base as AaveV3Base3 } from "@bgd-labs/aave-address-book";
+var positionContextProvider = {
+  name: "positionContextProvider",
+  description: "Provides current Aave V3 position context including supplies, borrows, and health metrics",
+  dynamic: true,
+  get: async (runtime, message, state) => {
+    logger9.debug("positionContextProvider::get");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const walletAddress = runtime.getSetting("WALLET_ADDRESS");
+    if (!rpcUrl) {
+      logger9.error("BASE_RPC_URL not configured");
+      return {
+        text: "Position data unavailable - RPC URL not configured",
+        data: { error: "RPC URL required" }
+      };
+    }
+    if (!walletAddress) {
+      logger9.debug(
+        "positionContextProvider: No wallet address configured, returning neutral context"
+      );
+      return {
+        text: "Position data available when wallet address is provided",
+        data: { provider: "positionContextProvider", status: "neutral" }
+      };
+    }
+    try {
+      const publicClient = createPublicClient3({
+        chain: base3,
+        transport: http3(rpcUrl)
+      });
+      const poolAddress = AaveV3Base3.POOL;
+      const userData = await publicClient.readContract({
+        address: poolAddress,
+        abi: [
+          {
+            inputs: [
+              { internalType: "address", name: "user", type: "address" }
+            ],
+            name: "getUserAccountData",
+            outputs: [
+              {
+                internalType: "uint256",
+                name: "totalCollateralETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "totalDebtETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "availableBorrowsETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "currentLiquidationThreshold",
+                type: "uint256"
+              },
+              { internalType: "uint256", name: "ltv", type: "uint256" },
+              {
+                internalType: "uint256",
+                name: "healthFactor",
+                type: "uint256"
+              }
+            ],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "getUserAccountData",
+        args: [walletAddress]
+      });
+      const [
+        totalCollateralETH,
+        totalDebtETH,
+        availableBorrowsETH,
+        currentLiquidationThreshold,
+        ltv,
+        healthFactor
+      ] = userData;
+      const totalCollateralBN = new BigNumber(
+        totalCollateralETH.toString()
+      ).dividedBy(1e18);
+      const totalDebtBN = new BigNumber(totalDebtETH.toString()).dividedBy(
+        1e18
+      );
+      const availableBorrowsBN = new BigNumber(
+        availableBorrowsETH.toString()
+      ).dividedBy(1e18);
+      const healthFactorBN = new BigNumber(healthFactor.toString()).dividedBy(
+        1e18
+      );
+      const currentLTV = totalCollateralBN.gt(0) ? totalDebtBN.dividedBy(totalCollateralBN).times(100) : new BigNumber(0);
+      const healthFactorFormatted = healthFactorBN.isFinite() ? healthFactorBN.toFixed(2) : "\u221E";
+      let positionStatus = "No Position";
+      if (totalCollateralBN.gt(0) && totalDebtBN.gt(0)) {
+        positionStatus = "Active Lending & Borrowing";
+      } else if (totalCollateralBN.gt(0)) {
+        positionStatus = "Lending Only";
+      } else if (totalDebtBN.gt(0)) {
+        positionStatus = "Borrowing Only";
+      }
+      let positionSummary = `Aave V3 Position Summary:
+
+Status: ${positionStatus}
+Total Collateral: ${totalCollateralBN.toFixed(4)} ETH
+Total Debt: ${totalDebtBN.toFixed(4)} ETH
+Available Borrows: ${availableBorrowsBN.toFixed(4)} ETH
+Current LTV: ${currentLTV.toFixed(1)}%
+Health Factor: ${healthFactorFormatted}`;
+      const recommendations = [];
+      if (totalCollateralBN.eq(0) && totalDebtBN.eq(0)) {
+        recommendations.push(
+          "No active position - consider supplying assets to earn yield"
+        );
+        recommendations.push(
+          "Start with stable assets like USDC for lower risk"
+        );
+      } else if (totalDebtBN.eq(0)) {
+        recommendations.push(
+          "Consider borrowing against your collateral if you need liquidity"
+        );
+        recommendations.push(
+          "Monitor supply APY rates for optimization opportunities"
+        );
+      } else if (healthFactorBN.lt(1.5) && healthFactorBN.isFinite()) {
+        recommendations.push(
+          "\u26A0\uFE0F Health factor is low - consider adding collateral or repaying debt"
+        );
+        recommendations.push("Monitor position closely to avoid liquidation");
+      } else {
+        recommendations.push(
+          "Position looks healthy - monitor rates for optimization"
+        );
+        if (availableBorrowsBN.gt(0)) {
+          recommendations.push(
+            `You can still borrow up to ${availableBorrowsBN.toFixed(4)} ETH`
+          );
+        }
+      }
+      if (recommendations.length > 0) {
+        positionSummary += `
+
+Recommendations:
+${recommendations.map((r) => `- ${r}`).join("\n")}`;
+      }
+      return {
+        text: positionSummary,
+        data: {
+          address: walletAddress,
+          status: positionStatus.toLowerCase().replace(/\s+/g, "_"),
+          totalCollateral: totalCollateralBN.toNumber(),
+          totalDebt: totalDebtBN.toNumber(),
+          availableBorrows: availableBorrowsBN.toNumber(),
+          currentLTV: currentLTV.toNumber(),
+          healthFactor: healthFactorBN.isFinite() ? healthFactorBN.toNumber() : null,
+          recommendations,
+          hasSupplies: totalCollateralBN.gt(0),
+          hasBorrows: totalDebtBN.gt(0),
+          liquidationThreshold: new BigNumber(
+            currentLiquidationThreshold.toString()
+          ).dividedBy(1e4).times(100).toNumber()
+        },
+        values: {
+          totalCollateral: totalCollateralBN.toNumber(),
+          totalDebt: totalDebtBN.toNumber(),
+          availableBorrows: availableBorrowsBN.toNumber(),
+          currentLTV: currentLTV.toNumber(),
+          healthFactor: healthFactorBN.isFinite() ? healthFactorBN.toNumber() : null,
+          utilizationRate: totalCollateralBN.gt(0) ? totalDebtBN.dividedBy(totalCollateralBN).toNumber() : 0
+        }
+      };
+    } catch (error) {
+      logger9.error("positionContextProvider: Error fetching position data:", {
+        error: error instanceof Error ? error.message : String(error),
+        address: walletAddress,
+        rpcUrl
+      });
+      return {
+        text: "Position data temporarily unavailable",
+        data: {
+          provider: "positionContextProvider",
+          status: "error",
+          error: error instanceof Error ? error.message : String(error),
+          address: walletAddress
+        }
+      };
+    }
+  }
+};
+
+// src/providers/healthFactor.ts
+import {
+  logger as logger10
+} from "@elizaos/core";
+import BigNumber2 from "bignumber.js";
+import { createPublicClient as createPublicClient4, http as http4 } from "viem";
+import { base as base4 } from "viem/chains";
+import { AaveV3Base as AaveV3Base4 } from "@bgd-labs/aave-address-book";
+var healthFactorProvider = {
+  name: "healthFactorProvider",
+  description: "Provides detailed health factor analysis and risk assessment for Aave V3 positions",
+  dynamic: true,
+  get: async (runtime, message, state) => {
+    logger10.debug("healthFactorProvider::get");
+    const rpcUrl = runtime.getSetting("BASE_RPC_URL");
+    const walletAddress = runtime.getSetting("WALLET_ADDRESS");
+    if (!rpcUrl) {
+      logger10.error("BASE_RPC_URL not configured");
+      return {
+        text: "Health factor data unavailable - RPC URL not configured",
+        data: { error: "RPC URL required" }
+      };
+    }
+    if (!walletAddress) {
+      logger10.debug(
+        "healthFactorProvider: No wallet address configured, returning neutral context"
+      );
+      return {
+        text: "Health factor data available when wallet address is provided",
+        data: { provider: "healthFactorProvider", status: "neutral" }
+      };
+    }
+    try {
+      const publicClient = createPublicClient4({
+        chain: base4,
+        transport: http4(rpcUrl)
+      });
+      const poolAddress = AaveV3Base4.POOL;
+      const userData = await publicClient.readContract({
+        address: poolAddress,
+        abi: [
+          {
+            inputs: [
+              { internalType: "address", name: "user", type: "address" }
+            ],
+            name: "getUserAccountData",
+            outputs: [
+              {
+                internalType: "uint256",
+                name: "totalCollateralETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "totalDebtETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "availableBorrowsETH",
+                type: "uint256"
+              },
+              {
+                internalType: "uint256",
+                name: "currentLiquidationThreshold",
+                type: "uint256"
+              },
+              { internalType: "uint256", name: "ltv", type: "uint256" },
+              {
+                internalType: "uint256",
+                name: "healthFactor",
+                type: "uint256"
+              }
+            ],
+            stateMutability: "view",
+            type: "function"
+          }
+        ],
+        functionName: "getUserAccountData",
+        args: [walletAddress]
+      });
+      const [
+        totalCollateralETH,
+        totalDebtETH,
+        availableBorrowsETH,
+        currentLiquidationThreshold,
+        ltv,
+        healthFactor
+      ] = userData;
+      const healthFactorBN = new BigNumber2(healthFactor.toString()).dividedBy(
+        1e18
+      );
+      const totalCollateralBN = new BigNumber2(
+        totalCollateralETH.toString()
+      ).dividedBy(1e18);
+      const totalDebtBN = new BigNumber2(totalDebtETH.toString()).dividedBy(
+        1e18
+      );
+      if (totalDebtBN.eq(0)) {
+        return {
+          text: "No debt position found - health factor analysis not applicable",
+          data: {
+            address: walletAddress,
+            healthFactor: null,
+            status: "no_debt",
+            totalCollateral: totalCollateralBN.toNumber(),
+            totalDebt: 0
+          },
+          values: {
+            healthFactor: null,
+            totalCollateral: totalCollateralBN.toNumber(),
+            totalDebt: 0
+          }
+        };
+      }
+      const healthFactorFormatted = healthFactorBN.isFinite() ? healthFactorBN.toFixed(2) : "\u221E";
+      const analysis = analyzeHealthFactor(healthFactorBN);
+      const recommendations = getRecommendations(healthFactorBN);
+      const ltvBN = new BigNumber2(ltv.toString()).dividedBy(1e4);
+      const currentLTV = totalCollateralBN.gt(0) ? totalDebtBN.dividedBy(totalCollateralBN).times(100) : new BigNumber2(0);
+      let liquidationInfo = "";
+      if (healthFactorBN.lt(1.5) && healthFactorBN.isFinite()) {
+        const liquidationThresholdBN = new BigNumber2(
+          currentLiquidationThreshold.toString()
+        ).dividedBy(1e4);
+        const collateralDropToLiquidation = totalCollateralBN.times(healthFactorBN.minus(1).dividedBy(healthFactorBN)).times(100);
+        liquidationInfo = `
+Liquidation Risk Analysis:
+- Collateral can drop ${collateralDropToLiquidation.toFixed(1)}% before liquidation
+- Current liquidation threshold: ${liquidationThresholdBN.times(100).toFixed(1)}%`;
+      }
+      const summary = `Health Factor Analysis:
+
+${analysis.emoji} Health Factor: ${healthFactorFormatted}
+Status: ${analysis.status}
+Risk Level: ${analysis.riskLevel}
+
+Safety Metrics:
+- Current LTV: ${currentLTV.toFixed(1)}% / Max LTV: ${ltvBN.times(100).toFixed(1)}%
+- Total Collateral: ${totalCollateralBN.toFixed(4)} ETH
+- Total Debt: ${totalDebtBN.toFixed(4)} ETH
+${liquidationInfo}
+
+Recommendations:
+${recommendations.map((r) => `- ${r}`).join("\n")}
+
+Remember: Health Factor > 1.0 prevents liquidation. Aim for > 1.5 for safety.`;
+      return {
+        text: summary,
+        data: {
+          address: walletAddress,
+          healthFactor: healthFactorBN.toNumber(),
+          status: analysis.status.toLowerCase().replace(" ", "_"),
+          riskLevel: analysis.riskLevel,
+          totalCollateral: totalCollateralBN.toNumber(),
+          totalDebt: totalDebtBN.toNumber(),
+          currentLTV: currentLTV.toNumber(),
+          maxLTV: ltvBN.times(100).toNumber(),
+          recommendations,
+          liquidationThreshold: new BigNumber2(
+            currentLiquidationThreshold.toString()
+          ).dividedBy(1e4).times(100).toNumber()
+        },
+        values: {
+          healthFactor: healthFactorBN.toNumber(),
+          totalCollateral: totalCollateralBN.toNumber(),
+          totalDebt: totalDebtBN.toNumber(),
+          currentLTV: currentLTV.toNumber(),
+          riskScore: calculateRiskScore(healthFactorBN)
+        }
+      };
+    } catch (error) {
+      logger10.error("healthFactorProvider: Error fetching health factor data:", {
+        error: error instanceof Error ? error.message : String(error),
+        address: walletAddress,
+        rpcUrl
+      });
+      return {
+        text: "Health factor data temporarily unavailable",
+        data: {
+          provider: "healthFactorProvider",
+          status: "error",
+          error: error instanceof Error ? error.message : String(error),
+          address: walletAddress
+        }
+      };
+    }
+  }
+};
+function analyzeHealthFactor(healthFactor) {
+  if (!healthFactor.isFinite()) {
+    return {
+      status: "No Debt Position",
+      riskLevel: "No Risk",
+      emoji: "\u{1F7E2}"
+    };
+  }
+  if (healthFactor.lt(1)) {
+    return {
+      status: "LIQUIDATABLE",
+      riskLevel: "EXTREME - Liquidation Active",
+      emoji: "\u{1F534}\u{1F6A8}"
+    };
+  } else if (healthFactor.lt(1.1)) {
+    return {
+      status: "CRITICAL",
+      riskLevel: "Very High - Immediate Action Required",
+      emoji: "\u{1F534}"
+    };
+  } else if (healthFactor.lt(1.5)) {
+    return {
+      status: "RISKY",
+      riskLevel: "High - Monitor Closely",
+      emoji: "\u{1F7E1}"
+    };
+  } else if (healthFactor.lt(2)) {
+    return {
+      status: "MODERATE",
+      riskLevel: "Medium - Acceptable Risk",
+      emoji: "\u{1F7E2}"
+    };
+  } else if (healthFactor.lt(3)) {
+    return {
+      status: "SAFE",
+      riskLevel: "Low",
+      emoji: "\u{1F7E2}"
+    };
+  } else {
+    return {
+      status: "VERY SAFE",
+      riskLevel: "Very Low",
+      emoji: "\u{1F7E2}"
+    };
+  }
+}
+function getRecommendations(healthFactor) {
+  const recommendations = [];
+  if (!healthFactor.isFinite()) {
+    recommendations.push(
+      "Consider borrowing against your collateral to put it to work"
+    );
+    recommendations.push("Your position is risk-free with no debt");
+    return recommendations;
+  }
+  if (healthFactor.lt(1.1)) {
+    recommendations.push(
+      "\u{1F6A8} URGENT: Add collateral immediately to avoid liquidation"
+    );
+    recommendations.push("\u{1F6A8} URGENT: Repay debt to improve health factor");
+    recommendations.push(
+      "Consider using a flash loan to restructure your position"
+    );
+  } else if (healthFactor.lt(1.5)) {
+    recommendations.push("Add more collateral to create a safety buffer");
+    recommendations.push(
+      "Consider repaying some debt to improve your position"
+    );
+    recommendations.push("Monitor market prices closely for your assets");
+    recommendations.push("Set up alerts for health factor changes");
+  } else if (healthFactor.lt(2)) {
+    recommendations.push(
+      "Your position is relatively safe but monitor regularly"
+    );
+    recommendations.push("Consider your risk tolerance before borrowing more");
+  } else {
+    recommendations.push("Your position is very safe");
+    recommendations.push("You have room to borrow more if needed");
+    recommendations.push(
+      "Consider enabling eMode for better capital efficiency"
+    );
+  }
+  return recommendations;
+}
+function calculateRiskScore(healthFactor) {
+  if (!healthFactor.isFinite()) {
+    return 0;
+  }
+  if (healthFactor.lt(1)) {
+    return 100;
+  } else if (healthFactor.lt(1.1)) {
+    return 90;
+  } else if (healthFactor.lt(1.5)) {
+    return 70;
+  } else if (healthFactor.lt(2)) {
+    return 40;
+  } else if (healthFactor.lt(3)) {
+    return 20;
+  } else {
+    return 10;
+  }
+}
+
+// src/types/index.ts
+import BigNumber3 from "bignumber.js";
+var InterestRateMode = /* @__PURE__ */ ((InterestRateMode2) => {
+  InterestRateMode2[InterestRateMode2["NONE"] = 0] = "NONE";
+  InterestRateMode2[InterestRateMode2["STABLE"] = 1] = "STABLE";
+  InterestRateMode2[InterestRateMode2["VARIABLE"] = 2] = "VARIABLE";
+  return InterestRateMode2;
+})(InterestRateMode || {});
+var HealthFactorStatus = /* @__PURE__ */ ((HealthFactorStatus2) => {
+  HealthFactorStatus2["CRITICAL"] = "CRITICAL";
+  HealthFactorStatus2["RISKY"] = "RISKY";
+  HealthFactorStatus2["MODERATE"] = "MODERATE";
+  HealthFactorStatus2["SAFE"] = "SAFE";
+  HealthFactorStatus2["VERY_SAFE"] = "VERY_SAFE";
+  return HealthFactorStatus2;
+})(HealthFactorStatus || {});
+
+// src/index.ts
+var aavePlugin = {
+  name: "aave",
+  description: "Aave V3 integration plugin for ElizaOS - enabling DeFi lending and borrowing capabilities on Base L2",
+  actions: [
+    supplyAction,
+    borrowAction,
+    repayAction,
+    withdrawAction,
+    rateSwitchAction,
+    collateralManagementAction,
+    eModeAction,
+    flashLoanAction
+  ],
+  providers: [positionContextProvider, healthFactorProvider]
+};
+var index_default = aavePlugin;
+export {
+  BigNumber3 as BigNumber,
+  HealthFactorStatus,
+  InterestRateMode,
+  aavePlugin,
+  borrowAction,
+  collateralManagementAction,
+  index_default as default,
+  eModeAction,
+  flashLoanAction,
+  healthFactorProvider,
+  positionContextProvider,
+  rateSwitchAction,
+  repayAction,
+  supplyAction,
+  withdrawAction
+};
+//# sourceMappingURL=index.js.map