@emberai/onchain-actions-registry 3.0.0-alpha.2 → 3.0.0-alpha.3

package/dist/index.cjs

@@ -1,1536 +1,1362 @@
-"use strict";
+//#region rolldown:runtime
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BorrowTokensRequestSchema: () => BorrowTokensRequestSchema,
-  BorrowTokensResponseSchema: () => BorrowTokensResponseSchema,
-  ChainSchema: () => ChainSchema,
-  ChainTypeSchema: () => ChainTypeSchema,
-  ClosePerpetualsOrdersRequestSchema: () => ClosePerpetualsOrdersRequestSchema,
-  ClosePerpetualsOrdersResponseSchema: () => ClosePerpetualsOrdersResponseSchema,
-  CreatePerpetualsPositionRequestSchema: () => CreatePerpetualsPositionRequestSchema,
-  CreatePerpetualsPositionResponseSchema: () => CreatePerpetualsPositionResponseSchema,
-  DecreasePositionSwapTypeSchema: () => DecreasePositionSwapTypeSchema,
-  FeeBreakdownSchema: () => FeeBreakdownSchema,
-  GetLiquidityPoolsResponseSchema: () => GetLiquidityPoolsResponseSchema,
-  GetPerpetualsMarketsOrdersRequestSchema: () => GetPerpetualsMarketsOrdersRequestSchema,
-  GetPerpetualsMarketsOrdersResponseSchema: () => GetPerpetualsMarketsOrdersResponseSchema,
-  GetPerpetualsMarketsPositionsRequestSchema: () => GetPerpetualsMarketsPositionsRequestSchema,
-  GetPerpetualsMarketsPositionsResponseSchema: () => GetPerpetualsMarketsPositionsResponseSchema,
-  GetPerpetualsMarketsRequestSchema: () => GetPerpetualsMarketsRequestSchema,
-  GetPerpetualsMarketsResponseSchema: () => GetPerpetualsMarketsResponseSchema,
-  GetWalletLendingPositionsRequestSchema: () => GetWalletLendingPositionsRequestSchema,
-  GetWalletLendingPositionsResponseSchema: () => GetWalletLendingPositionsResponseSchema,
-  GetWalletLiquidityPositionsRequestSchema: () => GetWalletLiquidityPositionsRequestSchema,
-  GetWalletLiquidityPositionsResponseSchema: () => GetWalletLiquidityPositionsResponseSchema,
-  LendTokenDetailSchema: () => LendTokenDetailSchema,
-  LimitedLiquidityProvisionRangeSchema: () => LimitedLiquidityProvisionRangeSchema,
-  LiquidityPayTokensSchema: () => LiquidityPayTokensSchema,
-  LiquidityPoolSchema: () => LiquidityPoolSchema,
-  LiquidityPoolTokens: () => LiquidityPoolTokens,
-  LiquidityPositionRangeSchema: () => LiquidityPositionRangeSchema,
-  LiquidityPositionSchema: () => LiquidityPositionSchema,
-  LiquidityProvisionRangeSchema: () => LiquidityProvisionRangeSchema,
-  LiquiditySuppliedTokenSchema: () => LiquiditySuppliedTokenSchema,
-  OrderSchema: () => OrderSchema,
-  OrderTypeSchema: () => OrderTypeSchema,
-  OrdersDataSchema: () => OrdersDataSchema,
-  PerpetualMarketSchema: () => PerpetualMarketSchema,
-  PositionSchema: () => PositionSchema,
-  PositionSideSchema: () => PositionSideSchema,
-  PositionsDataSchema: () => PositionsDataSchema,
-  ProviderTrackingInfoSchema: () => ProviderTrackingInfoSchema,
-  ProviderTrackingStatusSchema: () => ProviderTrackingStatusSchema,
-  PublicEmberPluginRegistry: () => PublicEmberPluginRegistry,
-  RepayTokensRequestSchema: () => RepayTokensRequestSchema,
-  RepayTokensResponseSchema: () => RepayTokensResponseSchema,
-  SupplyLiquidityRequestSchema: () => SupplyLiquidityRequestSchema,
-  SupplyLiquidityResponseSchema: () => SupplyLiquidityResponseSchema,
-  SupplyTokensRequestSchema: () => SupplyTokensRequestSchema,
-  SupplyTokensResponseSchema: () => SupplyTokensResponseSchema,
-  SwapEstimationSchema: () => SwapEstimationSchema,
-  SwapTokensRequestSchema: () => SwapTokensRequestSchema,
-  SwapTokensResponseSchema: () => SwapTokensResponseSchema,
-  TokenIdentifierSchema: () => TokenIdentifierSchema,
-  TokenSchema: () => TokenSchema,
-  TransactionPlanErrorSchema: () => TransactionPlanErrorSchema,
-  TransactionPlanSchema: () => TransactionPlanSchema,
-  TransactionTypeSchema: () => TransactionTypeSchema,
-  TransactionTypes: () => TransactionTypes,
-  WithdrawLiquidityRequestSchema: () => WithdrawLiquidityRequestSchema,
-  WithdrawLiquidityResponseSchema: () => WithdrawLiquidityResponseSchema,
-  WithdrawTokensRequestSchema: () => WithdrawTokensRequestSchema,
-  WithdrawTokensResponseSchema: () => WithdrawTokensResponseSchema,
-  initializePublicRegistry: () => initializePublicRegistry
-});
-module.exports = __toCommonJS(index_exports);
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
 
-// src/aave-lending-plugin/adapter.ts
-var import_contract_helpers2 = require("@aave/contract-helpers");
-var import_ethers3 = require("ethers");
+//#endregion
+let __aave_contract_helpers = require("@aave/contract-helpers");
+let ethers = require("ethers");
+let zod = require("zod");
+let __bgd_labs_aave_address_book = require("@bgd-labs/aave-address-book");
+__bgd_labs_aave_address_book = __toESM(__bgd_labs_aave_address_book);
+let __aave_math_utils = require("@aave/math-utils");
 
-// src/core/schemas/core.ts
-var import_zod2 = require("zod");
-
-// src/core/schemas/enums.ts
-var import_zod = require("zod");
-var ChainTypeSchema = import_zod.z.enum(["UNSPECIFIED", "EVM", "SOLANA", "COSMOS"]);
-var TransactionTypes = {
-  TRANSACTION_TYPE_UNSPECIFIED: "TRANSACTION_TYPE_UNSPECIFIED",
-  EVM_TX: "EVM_TX",
-  SOLANA_TX: "SOLANA_TX"
+//#region src/core/schemas/enums.ts
+const ChainTypeSchema = zod.z.enum([
+	"UNSPECIFIED",
+	"EVM",
+	"SOLANA",
+	"COSMOS"
+]);
+const TransactionTypes = {
+	TRANSACTION_TYPE_UNSPECIFIED: "TRANSACTION_TYPE_UNSPECIFIED",
+	EVM_TX: "EVM_TX",
+	SOLANA_TX: "SOLANA_TX"
 };
-var TransactionTypeSchema = import_zod.z.enum(
-  Object.values(TransactionTypes)
-);
+const TransactionTypeSchema = zod.z.enum(Object.values(TransactionTypes));
 
-// src/core/schemas/core.ts
-var TokenIdentifierSchema = import_zod2.z.object({
-  chainId: import_zod2.z.string(),
-  address: import_zod2.z.string()
+//#endregion
+//#region src/core/schemas/core.ts
+const TokenIdentifierSchema = zod.z.object({
+	chainId: zod.z.string(),
+	address: zod.z.string()
 });
-var TokenSchema = import_zod2.z.object({
-  tokenUid: TokenIdentifierSchema,
-  name: import_zod2.z.string(),
-  symbol: import_zod2.z.string(),
-  isNative: import_zod2.z.boolean(),
-  decimals: import_zod2.z.number().int(),
-  iconUri: import_zod2.z.string().nullish(),
-  isVetted: import_zod2.z.boolean()
+const TokenSchema = zod.z.object({
+	tokenUid: TokenIdentifierSchema,
+	name: zod.z.string(),
+	symbol: zod.z.string(),
+	isNative: zod.z.boolean(),
+	decimals: zod.z.number().int(),
+	iconUri: zod.z.string().nullish(),
+	isVetted: zod.z.boolean()
 });
-var ChainSchema = import_zod2.z.object({
-  chainId: import_zod2.z.string(),
-  type: ChainTypeSchema,
-  iconUri: import_zod2.z.string(),
-  nativeToken: TokenSchema,
-  httpRpcUrl: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  blockExplorerUrls: import_zod2.z.array(import_zod2.z.string())
+const ChainSchema = zod.z.object({
+	chainId: zod.z.string(),
+	type: ChainTypeSchema,
+	iconUri: zod.z.string(),
+	nativeToken: TokenSchema,
+	httpRpcUrl: zod.z.string(),
+	name: zod.z.string(),
+	blockExplorerUrls: zod.z.array(zod.z.string())
 });
-var FeeBreakdownSchema = import_zod2.z.object({
-  serviceFee: import_zod2.z.string(),
-  slippageCost: import_zod2.z.string(),
-  total: import_zod2.z.string(),
-  feeDenomination: import_zod2.z.string()
+const FeeBreakdownSchema = zod.z.object({
+	serviceFee: zod.z.string(),
+	slippageCost: zod.z.string(),
+	total: zod.z.string(),
+	feeDenomination: zod.z.string()
 });
-var TransactionPlanSchema = import_zod2.z.object({
-  type: TransactionTypeSchema,
-  to: import_zod2.z.string(),
-  data: import_zod2.z.string(),
-  value: import_zod2.z.string(),
-  chainId: import_zod2.z.string()
+const TransactionPlanSchema = zod.z.object({
+	type: TransactionTypeSchema,
+	to: zod.z.string(),
+	data: zod.z.string(),
+	value: zod.z.string(),
+	chainId: zod.z.string()
 });
-var TransactionPlanErrorSchema = import_zod2.z.object({
-  code: import_zod2.z.string(),
-  message: import_zod2.z.string(),
-  details: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string())
+const TransactionPlanErrorSchema = zod.z.object({
+	code: zod.z.string(),
+	message: zod.z.string(),
+	details: zod.z.record(zod.z.string(), zod.z.string())
 });
-var ProviderTrackingInfoSchema = import_zod2.z.object({
-  requestId: import_zod2.z.string(),
-  providerName: import_zod2.z.string(),
-  explorerUrl: import_zod2.z.string()
+const ProviderTrackingInfoSchema = zod.z.object({
+	requestId: zod.z.string(),
+	providerName: zod.z.string(),
+	explorerUrl: zod.z.string()
 });
-var SwapEstimationSchema = import_zod2.z.object({
-  effectivePrice: import_zod2.z.string(),
-  timeEstimate: import_zod2.z.string(),
-  expiration: import_zod2.z.string()
+const SwapEstimationSchema = zod.z.object({
+	effectivePrice: zod.z.string(),
+	timeEstimate: zod.z.string(),
+	expiration: zod.z.string()
 });
-var ProviderTrackingStatusSchema = import_zod2.z.object({
-  requestId: import_zod2.z.string(),
-  transactionId: import_zod2.z.string(),
-  providerName: import_zod2.z.string(),
-  explorerUrl: import_zod2.z.string(),
-  status: import_zod2.z.string()
+const ProviderTrackingStatusSchema = zod.z.object({
+	requestId: zod.z.string(),
+	transactionId: zod.z.string(),
+	providerName: zod.z.string(),
+	explorerUrl: zod.z.string(),
+	status: zod.z.string()
 });
 
-// src/core/schemas/lending.ts
-var import_zod3 = require("zod");
-var BorrowTokensRequestSchema = import_zod3.z.object({
-  borrowToken: TokenSchema,
-  amount: import_zod3.z.bigint(),
-  walletAddress: import_zod3.z.string()
+//#endregion
+//#region src/core/schemas/lending.ts
+const BorrowTokensRequestSchema = zod.z.object({
+	borrowToken: TokenSchema,
+	amount: zod.z.bigint(),
+	walletAddress: zod.z.string()
 });
-var BorrowTokensResponseSchema = import_zod3.z.object({
-  currentBorrowApy: import_zod3.z.string(),
-  liquidationThreshold: import_zod3.z.string(),
-  feeBreakdown: FeeBreakdownSchema.optional(),
-  transactions: import_zod3.z.array(TransactionPlanSchema)
+const BorrowTokensResponseSchema = zod.z.object({
+	currentBorrowApy: zod.z.string(),
+	liquidationThreshold: zod.z.string(),
+	feeBreakdown: FeeBreakdownSchema.optional(),
+	transactions: zod.z.array(TransactionPlanSchema)
 });
-var RepayTokensRequestSchema = import_zod3.z.object({
-  repayToken: TokenSchema,
-  amount: import_zod3.z.bigint(),
-  walletAddress: import_zod3.z.string()
+const RepayTokensRequestSchema = zod.z.object({
+	repayToken: TokenSchema,
+	amount: zod.z.bigint(),
+	walletAddress: zod.z.string()
 });
-var RepayTokensResponseSchema = import_zod3.z.object({
-  feeBreakdown: FeeBreakdownSchema.optional(),
-  transactions: import_zod3.z.array(TransactionPlanSchema)
+const RepayTokensResponseSchema = zod.z.object({
+	feeBreakdown: FeeBreakdownSchema.optional(),
+	transactions: zod.z.array(TransactionPlanSchema)
 });
-var SupplyTokensRequestSchema = import_zod3.z.object({
-  supplyToken: TokenSchema,
-  amount: import_zod3.z.bigint(),
-  walletAddress: import_zod3.z.string()
+const SupplyTokensRequestSchema = zod.z.object({
+	supplyToken: TokenSchema,
+	amount: zod.z.bigint(),
+	walletAddress: zod.z.string()
 });
-var SupplyTokensResponseSchema = import_zod3.z.object({
-  feeBreakdown: FeeBreakdownSchema.optional(),
-  transactions: import_zod3.z.array(TransactionPlanSchema)
+const SupplyTokensResponseSchema = zod.z.object({
+	feeBreakdown: FeeBreakdownSchema.optional(),
+	transactions: zod.z.array(TransactionPlanSchema)
 });
-var WithdrawTokensRequestSchema = import_zod3.z.object({
-  tokenToWithdraw: TokenSchema,
-  amount: import_zod3.z.bigint(),
-  walletAddress: import_zod3.z.string()
+const WithdrawTokensRequestSchema = zod.z.object({
+	tokenToWithdraw: TokenSchema,
+	amount: zod.z.bigint(),
+	walletAddress: zod.z.string()
 });
-var WithdrawTokensResponseSchema = import_zod3.z.object({
-  feeBreakdown: FeeBreakdownSchema.optional(),
-  transactions: import_zod3.z.array(TransactionPlanSchema)
+const WithdrawTokensResponseSchema = zod.z.object({
+	feeBreakdown: FeeBreakdownSchema.optional(),
+	transactions: zod.z.array(TransactionPlanSchema)
 });
-var GetWalletLendingPositionsRequestSchema = import_zod3.z.object({
-  walletAddress: import_zod3.z.string(),
-  chainId: import_zod3.z.string().optional(),
-  tokenAddress: import_zod3.z.string().optional()
+const GetWalletLendingPositionsRequestSchema = zod.z.object({
+	walletAddress: zod.z.string(),
+	chainId: zod.z.string().optional(),
+	tokenAddress: zod.z.string().optional()
 });
-var LendTokenDetailSchema = import_zod3.z.object({
-  tokenUid: TokenIdentifierSchema,
-  underlyingBalance: import_zod3.z.string(),
-  underlyingBalanceUsd: import_zod3.z.string(),
-  variableBorrows: import_zod3.z.string(),
-  variableBorrowsUsd: import_zod3.z.string(),
-  totalBorrows: import_zod3.z.string(),
-  totalBorrowsUsd: import_zod3.z.string()
+const LendTokenDetailSchema = zod.z.object({
+	tokenUid: TokenIdentifierSchema,
+	underlyingBalance: zod.z.string(),
+	underlyingBalanceUsd: zod.z.string(),
+	variableBorrows: zod.z.string(),
+	variableBorrowsUsd: zod.z.string(),
+	totalBorrows: zod.z.string(),
+	totalBorrowsUsd: zod.z.string()
 });
-var GetWalletLendingPositionsResponseSchema = import_zod3.z.object({
-  userReserves: import_zod3.z.array(LendTokenDetailSchema),
-  totalLiquidityUsd: import_zod3.z.string(),
-  totalCollateralUsd: import_zod3.z.string(),
-  totalBorrowsUsd: import_zod3.z.string(),
-  netWorthUsd: import_zod3.z.string(),
-  availableBorrowsUsd: import_zod3.z.string(),
-  currentLoanToValue: import_zod3.z.string(),
-  currentLiquidationThreshold: import_zod3.z.string(),
-  healthFactor: import_zod3.z.string()
+const GetWalletLendingPositionsResponseSchema = zod.z.object({
+	userReserves: zod.z.array(LendTokenDetailSchema),
+	totalLiquidityUsd: zod.z.string(),
+	totalCollateralUsd: zod.z.string(),
+	totalBorrowsUsd: zod.z.string(),
+	netWorthUsd: zod.z.string(),
+	availableBorrowsUsd: zod.z.string(),
+	currentLoanToValue: zod.z.string(),
+	currentLiquidationThreshold: zod.z.string(),
+	healthFactor: zod.z.string()
 });
 
-// src/core/schemas/liquidity.ts
-var import_zod4 = require("zod");
-var LimitedLiquidityProvisionRangeSchema = import_zod4.z.object({
-  minPrice: import_zod4.z.string(),
-  maxPrice: import_zod4.z.string()
+//#endregion
+//#region src/core/schemas/liquidity.ts
+const LimitedLiquidityProvisionRangeSchema = zod.z.object({
+	minPrice: zod.z.string(),
+	maxPrice: zod.z.string()
 });
-var LiquidityProvisionRangeSchema = import_zod4.z.discriminatedUnion("type", [
-  import_zod4.z.object({
-    type: import_zod4.z.literal("full")
-  }),
-  import_zod4.z.object({
-    type: import_zod4.z.literal("limited"),
-    minPrice: import_zod4.z.string(),
-    maxPrice: import_zod4.z.string()
-  })
-]);
-var LiquidityPositionRangeSchema = import_zod4.z.object({
-  fromPrice: import_zod4.z.string(),
-  toPrice: import_zod4.z.string()
+const LiquidityProvisionRangeSchema = zod.z.discriminatedUnion("type", [zod.z.object({ type: zod.z.literal("full") }), zod.z.object({
+	type: zod.z.literal("limited"),
+	minPrice: zod.z.string(),
+	maxPrice: zod.z.string()
+})]);
+const LiquidityPositionRangeSchema = zod.z.object({
+	fromPrice: zod.z.string(),
+	toPrice: zod.z.string()
 });
-var LiquiditySuppliedTokenSchema = import_zod4.z.object({
-  tokenUid: TokenIdentifierSchema,
-  suppliedAmount: import_zod4.z.string(),
-  owedTokens: import_zod4.z.string()
+const LiquiditySuppliedTokenSchema = zod.z.object({
+	tokenUid: TokenIdentifierSchema,
+	suppliedAmount: zod.z.string(),
+	owedTokens: zod.z.string()
 });
-var LiquidityPositionSchema = import_zod4.z.object({
-  poolIdentifier: TokenIdentifierSchema,
-  operator: import_zod4.z.string(),
-  suppliedTokens: import_zod4.z.array(LiquiditySuppliedTokenSchema),
-  price: import_zod4.z.string(),
-  providerId: import_zod4.z.string(),
-  positionRange: LiquidityPositionRangeSchema.optional()
+const LiquidityPositionSchema = zod.z.object({
+	poolIdentifier: TokenIdentifierSchema,
+	operator: zod.z.string(),
+	suppliedTokens: zod.z.array(LiquiditySuppliedTokenSchema),
+	price: zod.z.string(),
+	providerId: zod.z.string(),
+	positionRange: LiquidityPositionRangeSchema.optional()
 });
-var LiquidityPoolTokens = import_zod4.z.object({
-  tokenUid: TokenIdentifierSchema
+const LiquidityPoolTokens = zod.z.object({ tokenUid: TokenIdentifierSchema });
+const LiquidityPoolSchema = zod.z.object({
+	identifier: TokenIdentifierSchema,
+	tokens: zod.z.array(LiquidityPoolTokens),
+	price: zod.z.string(),
+	providerId: zod.z.string()
 });
-var LiquidityPoolSchema = import_zod4.z.object({
-  identifier: TokenIdentifierSchema,
-  tokens: import_zod4.z.array(LiquidityPoolTokens),
-  price: import_zod4.z.string(),
-  providerId: import_zod4.z.string()
+const LiquidityPayTokensSchema = zod.z.object({
+	token: TokenSchema,
+	supplyAmount: zod.z.bigint()
 });
-var LiquidityPayTokensSchema = import_zod4.z.object({
-  token: TokenSchema,
-  supplyAmount: import_zod4.z.bigint()
+const SupplyLiquidityRequestSchema = zod.z.object({
+	walletAddress: zod.z.string(),
+	poolToken: TokenSchema,
+	payTokens: zod.z.array(LiquidityPayTokensSchema),
+	range: LiquidityProvisionRangeSchema.optional()
 });
-var SupplyLiquidityRequestSchema = import_zod4.z.object({
-  walletAddress: import_zod4.z.string(),
-  poolToken: TokenSchema,
-  payTokens: import_zod4.z.array(LiquidityPayTokensSchema),
-  range: LiquidityProvisionRangeSchema.optional()
+const SupplyLiquidityResponseSchema = zod.z.object({
+	transactions: zod.z.array(TransactionPlanSchema),
+	poolIdentifier: TokenIdentifierSchema
 });
-var SupplyLiquidityResponseSchema = import_zod4.z.object({
-  transactions: import_zod4.z.array(TransactionPlanSchema),
-  poolIdentifier: TokenIdentifierSchema
+const WithdrawLiquidityRequestSchema = zod.z.object({
+	poolToken: TokenSchema,
+	walletAddress: zod.z.string()
 });
-var WithdrawLiquidityRequestSchema = import_zod4.z.object({
-  poolToken: TokenSchema,
-  walletAddress: import_zod4.z.string()
-});
-var WithdrawLiquidityResponseSchema = import_zod4.z.object({
-  transactions: import_zod4.z.array(TransactionPlanSchema),
-  chainId: import_zod4.z.string()
-});
-var GetWalletLiquidityPositionsRequestSchema = import_zod4.z.object({
-  walletAddress: import_zod4.z.string()
-});
-var GetWalletLiquidityPositionsResponseSchema = import_zod4.z.object({
-  positions: import_zod4.z.array(LiquidityPositionSchema)
-});
-var GetLiquidityPoolsResponseSchema = import_zod4.z.object({
-  liquidityPools: import_zod4.z.array(LiquidityPoolSchema)
+const WithdrawLiquidityResponseSchema = zod.z.object({
+	transactions: zod.z.array(TransactionPlanSchema),
+	chainId: zod.z.string()
 });
+const GetWalletLiquidityPositionsRequestSchema = zod.z.object({ walletAddress: zod.z.string() });
+const GetWalletLiquidityPositionsResponseSchema = zod.z.object({ positions: zod.z.array(LiquidityPositionSchema) });
+const GetLiquidityPoolsResponseSchema = zod.z.object({ liquidityPools: zod.z.array(LiquidityPoolSchema) });
 
-// src/core/schemas/perpetuals.ts
-var import_zod5 = require("zod");
-var DecreasePositionSwapTypeSchema = import_zod5.z.enum([
-  "NoSwap",
-  "SwapPnlTokenToCollateralToken",
-  "SwapCollateralTokenToPnlToken"
+//#endregion
+//#region src/core/schemas/perpetuals.ts
+const DecreasePositionSwapTypeSchema = zod.z.enum([
+	"NoSwap",
+	"SwapPnlTokenToCollateralToken",
+	"SwapCollateralTokenToPnlToken"
 ]);
-var PositionSideSchema = import_zod5.z.enum(["long", "short"]);
-var PositionSchema = import_zod5.z.object({
-  chainId: import_zod5.z.string(),
-  key: import_zod5.z.string(),
-  contractKey: import_zod5.z.string(),
-  account: import_zod5.z.string(),
-  marketAddress: import_zod5.z.string(),
-  collateralTokenAddress: import_zod5.z.string(),
-  sizeInUsd: import_zod5.z.string(),
-  sizeInTokens: import_zod5.z.string(),
-  collateralAmount: import_zod5.z.string(),
-  pendingBorrowingFeesUsd: import_zod5.z.string(),
-  increasedAtTime: import_zod5.z.string(),
-  decreasedAtTime: import_zod5.z.string(),
-  positionSide: PositionSideSchema,
-  isLong: import_zod5.z.boolean(),
-  fundingFeeAmount: import_zod5.z.string(),
-  claimableLongTokenAmount: import_zod5.z.string(),
-  claimableShortTokenAmount: import_zod5.z.string(),
-  isOpening: import_zod5.z.boolean().optional(),
-  pnl: import_zod5.z.string(),
-  positionFeeAmount: import_zod5.z.string(),
-  traderDiscountAmount: import_zod5.z.string(),
-  uiFeeAmount: import_zod5.z.string(),
-  data: import_zod5.z.string().optional()
+const PositionSideSchema = zod.z.enum(["long", "short"]);
+const PositionSchema = zod.z.object({
+	chainId: zod.z.string(),
+	key: zod.z.string(),
+	contractKey: zod.z.string(),
+	account: zod.z.string(),
+	marketAddress: zod.z.string(),
+	collateralTokenAddress: zod.z.string(),
+	sizeInUsd: zod.z.string(),
+	sizeInTokens: zod.z.string(),
+	collateralAmount: zod.z.string(),
+	pendingBorrowingFeesUsd: zod.z.string(),
+	increasedAtTime: zod.z.string(),
+	decreasedAtTime: zod.z.string(),
+	positionSide: PositionSideSchema,
+	isLong: zod.z.boolean(),
+	fundingFeeAmount: zod.z.string(),
+	claimableLongTokenAmount: zod.z.string(),
+	claimableShortTokenAmount: zod.z.string(),
+	isOpening: zod.z.boolean().optional(),
+	pnl: zod.z.string(),
+	positionFeeAmount: zod.z.string(),
+	traderDiscountAmount: zod.z.string(),
+	uiFeeAmount: zod.z.string(),
+	data: zod.z.string().optional()
 });
-var PositionsDataSchema = import_zod5.z.array(PositionSchema);
-var OrderTypeSchema = import_zod5.z.enum([
-  "MarketSwap",
-  "LimitSwap",
-  "MarketIncrease",
-  "LimitIncrease",
-  "MarketDecrease",
-  "LimitDecrease",
-  "StopLossDecrease",
-  "Liquidation",
-  "StopIncrease"
+const PositionsDataSchema = zod.z.array(PositionSchema);
+const OrderTypeSchema = zod.z.enum([
+	"MarketSwap",
+	"LimitSwap",
+	"MarketIncrease",
+	"LimitIncrease",
+	"MarketDecrease",
+	"LimitDecrease",
+	"StopLossDecrease",
+	"Liquidation",
+	"StopIncrease"
 ]);
-var OrderSchema = import_zod5.z.object({
-  chainId: import_zod5.z.string(),
-  key: import_zod5.z.string(),
-  account: import_zod5.z.string(),
-  callbackContract: import_zod5.z.string(),
-  initialCollateralTokenAddress: import_zod5.z.string(),
-  marketAddress: import_zod5.z.string(),
-  decreasePositionSwapType: DecreasePositionSwapTypeSchema,
-  receiver: import_zod5.z.string(),
-  swapPath: import_zod5.z.array(import_zod5.z.string()),
-  contractAcceptablePrice: import_zod5.z.string(),
-  contractTriggerPrice: import_zod5.z.string(),
-  callbackGasLimit: import_zod5.z.string(),
-  executionFee: import_zod5.z.string(),
-  initialCollateralDeltaAmount: import_zod5.z.string(),
-  minOutputAmount: import_zod5.z.string(),
-  sizeDeltaUsd: import_zod5.z.string(),
-  updatedAtTime: import_zod5.z.string(),
-  isFrozen: import_zod5.z.boolean(),
-  positionSide: PositionSideSchema,
-  orderType: OrderTypeSchema,
-  shouldUnwrapNativeToken: import_zod5.z.boolean(),
-  autoCancel: import_zod5.z.boolean(),
-  data: import_zod5.z.string().optional(),
-  uiFeeReceiver: import_zod5.z.string(),
-  validFromTime: import_zod5.z.string(),
-  title: import_zod5.z.string().optional()
-});
-var OrdersDataSchema = import_zod5.z.array(OrderSchema);
-var CreatePerpetualsPositionRequestSchema = import_zod5.z.object({
-  amount: import_zod5.z.bigint(),
-  walletAddress: import_zod5.z.string(),
-  chainId: import_zod5.z.string(),
-  marketAddress: import_zod5.z.string(),
-  payTokenAddress: import_zod5.z.string(),
-  collateralTokenAddress: import_zod5.z.string(),
-  referralCode: import_zod5.z.string().optional(),
-  limitPrice: import_zod5.z.string().optional(),
-  leverage: import_zod5.z.string()
+const OrderSchema = zod.z.object({
+	chainId: zod.z.string(),
+	key: zod.z.string(),
+	account: zod.z.string(),
+	callbackContract: zod.z.string(),
+	initialCollateralTokenAddress: zod.z.string(),
+	marketAddress: zod.z.string(),
+	decreasePositionSwapType: DecreasePositionSwapTypeSchema,
+	receiver: zod.z.string(),
+	swapPath: zod.z.array(zod.z.string()),
+	contractAcceptablePrice: zod.z.string(),
+	contractTriggerPrice: zod.z.string(),
+	callbackGasLimit: zod.z.string(),
+	executionFee: zod.z.string(),
+	initialCollateralDeltaAmount: zod.z.string(),
+	minOutputAmount: zod.z.string(),
+	sizeDeltaUsd: zod.z.string(),
+	updatedAtTime: zod.z.string(),
+	isFrozen: zod.z.boolean(),
+	positionSide: PositionSideSchema,
+	orderType: OrderTypeSchema,
+	shouldUnwrapNativeToken: zod.z.boolean(),
+	autoCancel: zod.z.boolean(),
+	data: zod.z.string().optional(),
+	uiFeeReceiver: zod.z.string(),
+	validFromTime: zod.z.string(),
+	title: zod.z.string().optional()
 });
-var CreatePerpetualsPositionResponseSchema = import_zod5.z.object({
-  transactions: import_zod5.z.array(TransactionPlanSchema)
+const OrdersDataSchema = zod.z.array(OrderSchema);
+const CreatePerpetualsPositionRequestSchema = zod.z.object({
+	amount: zod.z.bigint(),
+	walletAddress: zod.z.string(),
+	chainId: zod.z.string(),
+	marketAddress: zod.z.string(),
+	payTokenAddress: zod.z.string(),
+	collateralTokenAddress: zod.z.string(),
+	referralCode: zod.z.string().optional(),
+	limitPrice: zod.z.string().optional(),
+	leverage: zod.z.string()
 });
-var GetPerpetualsMarketsPositionsRequestSchema = import_zod5.z.object({
-  walletAddress: import_zod5.z.string().describe("User's wallet address")
+const CreatePerpetualsPositionResponseSchema = zod.z.object({ transactions: zod.z.array(TransactionPlanSchema) });
+const GetPerpetualsMarketsPositionsRequestSchema = zod.z.object({ walletAddress: zod.z.string().describe("User's wallet address") });
+const GetPerpetualsMarketsPositionsResponseSchema = zod.z.object({ positions: PositionsDataSchema });
+const GetPerpetualsMarketsOrdersRequestSchema = zod.z.object({ walletAddress: zod.z.string().describe("User's wallet address") });
+const GetPerpetualsMarketsOrdersResponseSchema = zod.z.object({ orders: OrdersDataSchema });
+const ClosePerpetualsOrdersRequestSchema = zod.z.object({
+	walletAddress: zod.z.string().describe("User's wallet address"),
+	key: zod.z.string()
 });
-var GetPerpetualsMarketsPositionsResponseSchema = import_zod5.z.object({
-  positions: PositionsDataSchema
-});
-var GetPerpetualsMarketsOrdersRequestSchema = import_zod5.z.object({
-  walletAddress: import_zod5.z.string().describe("User's wallet address")
-});
-var GetPerpetualsMarketsOrdersResponseSchema = import_zod5.z.object({
-  orders: OrdersDataSchema
-});
-var ClosePerpetualsOrdersRequestSchema = import_zod5.z.object({
-  walletAddress: import_zod5.z.string().describe("User's wallet address"),
-  key: import_zod5.z.string()
-});
-var ClosePerpetualsOrdersResponseSchema = import_zod5.z.object({
-  transactions: import_zod5.z.array(TransactionPlanSchema)
-});
-var GetPerpetualsMarketsRequestSchema = import_zod5.z.object({
-  chainIds: import_zod5.z.array(import_zod5.z.string())
-});
-var PerpetualMarketSchema = import_zod5.z.object({
-  marketToken: TokenIdentifierSchema,
-  indexToken: TokenIdentifierSchema,
-  longToken: TokenIdentifierSchema,
-  shortToken: TokenIdentifierSchema,
-  longFundingFee: import_zod5.z.string(),
-  shortFundingFee: import_zod5.z.string(),
-  longBorrowingFee: import_zod5.z.string(),
-  shortBorrowingFee: import_zod5.z.string(),
-  chainId: import_zod5.z.string(),
-  name: import_zod5.z.string()
-});
-var GetPerpetualsMarketsResponseSchema = import_zod5.z.object({
-  markets: import_zod5.z.array(PerpetualMarketSchema)
+const ClosePerpetualsOrdersResponseSchema = zod.z.object({ transactions: zod.z.array(TransactionPlanSchema) });
+const GetPerpetualsMarketsRequestSchema = zod.z.object({ chainIds: zod.z.array(zod.z.string()) });
+const PerpetualMarketSchema = zod.z.object({
+	marketToken: TokenIdentifierSchema,
+	indexToken: TokenIdentifierSchema,
+	longToken: TokenIdentifierSchema,
+	shortToken: TokenIdentifierSchema,
+	longFundingFee: zod.z.string(),
+	shortFundingFee: zod.z.string(),
+	longBorrowingFee: zod.z.string(),
+	shortBorrowingFee: zod.z.string(),
+	chainId: zod.z.string(),
+	name: zod.z.string()
 });
+const GetPerpetualsMarketsResponseSchema = zod.z.object({ markets: zod.z.array(PerpetualMarketSchema) });
 
-// src/core/schemas/swap.ts
-var import_zod6 = require("zod");
-var SwapTokensRequestSchema = import_zod6.z.object({
-  fromToken: TokenSchema,
-  toToken: TokenSchema,
-  amount: import_zod6.z.bigint(),
-  limitPrice: import_zod6.z.string().optional(),
-  slippageTolerance: import_zod6.z.string().optional(),
-  expiration: import_zod6.z.string().optional(),
-  recipient: import_zod6.z.string()
+//#endregion
+//#region src/core/schemas/swap.ts
+const SwapTokensRequestSchema = zod.z.object({
+	fromToken: TokenSchema,
+	toToken: TokenSchema,
+	amount: zod.z.bigint(),
+	limitPrice: zod.z.string().optional(),
+	slippageTolerance: zod.z.string().optional(),
+	expiration: zod.z.string().optional(),
+	recipient: zod.z.string()
 });
-var SwapTokensResponseSchema = import_zod6.z.object({
-  fromToken: TokenSchema,
-  toToken: TokenSchema,
-  exactFromAmount: import_zod6.z.string(),
-  displayFromAmount: import_zod6.z.string(),
-  exactToAmount: import_zod6.z.string(),
-  displayToAmount: import_zod6.z.string(),
-  transactions: import_zod6.z.array(TransactionPlanSchema),
-  feeBreakdown: FeeBreakdownSchema.optional(),
-  estimation: SwapEstimationSchema.optional(),
-  providerTracking: ProviderTrackingInfoSchema.optional()
+const SwapTokensResponseSchema = zod.z.object({
+	fromToken: TokenSchema,
+	toToken: TokenSchema,
+	exactFromAmount: zod.z.string(),
+	displayFromAmount: zod.z.string(),
+	exactToAmount: zod.z.string(),
+	displayToAmount: zod.z.string(),
+	transactions: zod.z.array(TransactionPlanSchema),
+	feeBreakdown: FeeBreakdownSchema.optional(),
+	estimation: SwapEstimationSchema.optional(),
+	providerTracking: ProviderTrackingInfoSchema.optional()
 });
 
-// src/aave-lending-plugin/chain.ts
-var import_ethers = require("ethers");
+//#endregion
+//#region src/aave-lending-plugin/chain.ts
+/**
+* Represents a blockchain network configuration used to create JSON-RPC providers and
+* hold basic chain-specific metadata.
+*
+* The Chain class encapsulates:
+* - a numeric chain identifier (id),
+* - an RPC URL to connect to the chain (rpcUrl),
+* - an optional wrapped native token address (wrappedNativeTokenAddress).
+*
+* @param id - The numeric identifier for the chain (e.g., 1 for Ethereum mainnet).
+* @param rpcUrl - The JSON-RPC endpoint URL used to create providers for this chain.
+* @param wrappedNativeTokenAddress - Optional address of the chain's wrapped native token (if applicable).
+*/
 var Chain = class {
-  constructor(id, rpcUrl, wrappedNativeTokenAddress) {
-    this.id = id;
-    this.rpcUrl = rpcUrl;
-    this.wrappedNativeTokenAddress = wrappedNativeTokenAddress;
-  }
-  /**
-   * Create and return an ethers.js JsonRpcProvider configured with this chain's RPC URL.
-   *
-   * This method constructs a new ethers.providers.JsonRpcProvider each time it is called.
-   * Consumers may cache the provider if they intend to reuse it to avoid allocating multiple instances.
-   *
-   * @returns An instance of ethers.providers.JsonRpcProvider configured with the chain's rpcUrl.
-   */
-  getProvider() {
-    return new import_ethers.ethers.providers.JsonRpcProvider(this.rpcUrl);
-  }
+	constructor(id, rpcUrl, wrappedNativeTokenAddress) {
+		this.id = id;
+		this.rpcUrl = rpcUrl;
+		this.wrappedNativeTokenAddress = wrappedNativeTokenAddress;
+	}
+	/**
+	* Create and return an ethers.js JsonRpcProvider configured with this chain's RPC URL.
+	*
+	* This method constructs a new ethers.providers.JsonRpcProvider each time it is called.
+	* Consumers may cache the provider if they intend to reuse it to avoid allocating multiple instances.
+	*
+	* @returns An instance of ethers.providers.JsonRpcProvider configured with the chain's rpcUrl.
+	*/
+	getProvider() {
+		return new ethers.ethers.providers.JsonRpcProvider(this.rpcUrl);
+	}
 };
 
-// src/aave-lending-plugin/dataProvider.ts
-var import_contract_helpers = require("@aave/contract-helpers");
-var UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN = {
-  11155111: import_contract_helpers.LegacyUiPoolDataProvider,
-  42161: import_contract_helpers.UiPoolDataProvider,
-  1: import_contract_helpers.UiPoolDataProvider
+//#endregion
+//#region src/aave-lending-plugin/dataProvider.ts
+const UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN = {
+	11155111: __aave_contract_helpers.LegacyUiPoolDataProvider,
+	42161: __aave_contract_helpers.UiPoolDataProvider,
+	1: __aave_contract_helpers.UiPoolDataProvider
 };
-var getUiPoolDataProviderImpl = (chainId) => {
-  const res = UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN[chainId];
-  if (!res) {
-    throw new Error(
-      "UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN does not contain this chain ID. Edit providers/aave/dataProvider.ts."
-    );
-  }
-  return res;
+const getUiPoolDataProviderImpl = (chainId) => {
+	const res = UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN[chainId];
+	if (!res) throw new Error("UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN does not contain this chain ID. Edit providers/aave/dataProvider.ts.");
+	return res;
 };
 
-// src/aave-lending-plugin/market.ts
-var markets = __toESM(require("@bgd-labs/aave-address-book"), 1);
-var marketMap = {
-  1: "AaveV3Ethereum",
-  11155111: "AaveV3Sepolia",
-  42161: "AaveV3Arbitrum",
-  421614: "AaveV3ArbitrumSepolia",
-  8453: "AaveV3Base",
-  137: "AaveV3Polygon",
-  10: "AaveV3Optimism"
+//#endregion
+//#region src/aave-lending-plugin/market.ts
+const marketMap = {
+	1: "AaveV3Ethereum",
+	11155111: "AaveV3Sepolia",
+	42161: "AaveV3Arbitrum",
+	421614: "AaveV3ArbitrumSepolia",
+	8453: "AaveV3Base",
+	137: "AaveV3Polygon",
+	10: "AaveV3Optimism"
 };
-var getMarket = (chainId) => {
-  const marketKey = marketMap[chainId];
-  if (!marketKey) {
-    throw new Error(
-      `AAVE: no market found for chain ID ${chainId}: modify providers/aave/market.ts`
-    );
-  }
-  const market = markets[marketKey];
-  if (!market) {
-    throw new Error(`No such market: ${marketKey}`);
-  }
-  return market;
+const getMarket = (chainId) => {
+	const marketKey = marketMap[chainId];
+	if (!marketKey) throw new Error(`AAVE: no market found for chain ID ${chainId}: modify providers/aave/market.ts`);
+	const market = __bgd_labs_aave_address_book[marketKey];
+	if (!market) throw new Error(`No such market: ${marketKey}`);
+	return market;
 };
 
-// src/aave-lending-plugin/populateTransaction.ts
-var import_ethers2 = require("ethers");
-
-// src/aave-lending-plugin/errors.ts
+//#endregion
+//#region src/aave-lending-plugin/errors.ts
 var AaveError = class extends Error {
-  description;
-  message;
-  constructor(code, name, description) {
-    const message = name + ` (${code}): ` + description;
-    super(message);
-    this.name = "AaveError";
-    this.description = description;
-    this.message = message;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
+	description;
+	message;
+	constructor(code, name, description) {
+		const message = name + ` (${code}): ` + description;
+		super(message);
+		this.name = "AaveError";
+		this.description = description;
+		this.message = message;
+		Object.setPrototypeOf(this, new.target.prototype);
+	}
 };
-var AAVE_ERROR_CODES = {
-  "1": {
-    name: "CALLER_NOT_POOL_ADMIN",
-    description: "The caller of the function is not a pool admin"
-  },
-  "2": {
-    name: "CALLER_NOT_EMERGENCY_ADMIN",
-    description: "The caller of the function is not an emergency admin"
-  },
-  "3": {
-    name: "CALLER_NOT_POOL_OR_EMERGENCY_ADMIN",
-    description: "The caller of the function is not a pool or emergency admin"
-  },
-  "4": {
-    name: "CALLER_NOT_RISK_OR_POOL_ADMIN",
-    description: "The caller of the function is not a risk or pool admin"
-  },
-  "5": {
-    name: "CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN",
-    description: "The caller of the function is not an asset listing or pool admin"
-  },
-  "6": {
-    name: "CALLER_NOT_BRIDGE",
-    description: "The caller of the function is not a bridge"
-  },
-  "7": {
-    name: "ADDRESSES_PROVIDER_NOT_REGISTERED",
-    description: "Pool addresses provider is not registered"
-  },
-  "8": {
-    name: "INVALID_ADDRESSES_PROVIDER_ID",
-    description: "Invalid id for the pool addresses provider"
-  },
-  "9": { name: "NOT_CONTRACT", description: "Address is not a contract" },
-  "10": {
-    name: "CALLER_NOT_POOL_CONFIGURATOR",
-    description: "The caller of the function is not the pool configurator"
-  },
-  "11": {
-    name: "CALLER_NOT_ATOKEN",
-    description: "The caller of the function is not an AToken"
-  },
-  "12": {
-    name: "INVALID_ADDRESSES_PROVIDER",
-    description: "The address of the pool addresses provider is invalid"
-  },
-  "13": {
-    name: "INVALID_FLASHLOAN_EXECUTOR_RETURN",
-    description: "Invalid return value of the flashloan executor function"
-  },
-  "14": {
-    name: "RESERVE_ALREADY_ADDED",
-    description: "Reserve has already been added to reserve list"
-  },
-  "15": {
-    name: "NO_MORE_RESERVES_ALLOWED",
-    description: "Maximum amount of reserves in the pool reached"
-  },
-  "16": {
-    name: "EMODE_CATEGORY_RESERVED",
-    description: "Zero eMode category is reserved for volatile heterogeneous assets"
-  },
-  "17": {
-    name: "INVALID_EMODE_CATEGORY_ASSIGNMENT",
-    description: "Invalid eMode category assignment to asset"
-  },
-  "18": {
-    name: "RESERVE_LIQUIDITY_NOT_ZERO",
-    description: "The liquidity of the reserve needs to be 0"
-  },
-  "19": {
-    name: "FLASHLOAN_PREMIUM_INVALID",
-    description: "Invalid flashloan premium"
-  },
-  "20": {
-    name: "INVALID_RESERVE_PARAMS",
-    description: "Invalid risk parameters for the reserve"
-  },
-  "21": {
-    name: "INVALID_EMODE_CATEGORY_PARAMS",
-    description: "Invalid risk parameters for the eMode category"
-  },
-  "22": {
-    name: "BRIDGE_PROTOCOL_FEE_INVALID",
-    description: "Invalid bridge protocol fee"
-  },
-  "23": {
-    name: "CALLER_MUST_BE_POOL",
-    description: "The caller of this function must be a pool"
-  },
-  "24": { name: "INVALID_MINT_AMOUNT", description: "Invalid amount to mint" },
-  "25": { name: "INVALID_BURN_AMOUNT", description: "Invalid amount to burn" },
-  "26": {
-    name: "INVALID_AMOUNT",
-    description: "Amount must be greater than 0"
-  },
-  "27": {
-    name: "RESERVE_INACTIVE",
-    description: "Action requires an active reserve"
-  },
-  "28": {
-    name: "RESERVE_FROZEN",
-    description: "Action cannot be performed because the reserve is frozen"
-  },
-  "29": {
-    name: "RESERVE_PAUSED",
-    description: "Action cannot be performed because the reserve is paused"
-  },
-  "30": {
-    name: "BORROWING_NOT_ENABLED",
-    description: "Borrowing is not enabled"
-  },
-  "32": {
-    name: "NOT_ENOUGH_AVAILABLE_USER_BALANCE",
-    description: "User cannot withdraw more than the available balance"
-  },
-  "33": {
-    name: "INVALID_INTEREST_RATE_MODE_SELECTED",
-    description: "Invalid interest rate mode selected"
-  },
-  "34": {
-    name: "COLLATERAL_BALANCE_IS_ZERO",
-    description: "The collateral balance is 0"
-  },
-  "35": {
-    name: "HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD",
-    description: "Health factor is lesser than the liquidation threshold"
-  },
-  "36": {
-    name: "COLLATERAL_CANNOT_COVER_NEW_BORROW",
-    description: "There is not enough collateral to cover a new borrow"
-  },
-  "37": {
-    name: "COLLATERAL_SAME_AS_BORROWING_CURRENCY",
-    description: "Collateral is (mostly) the same currency that is being borrowed"
-  },
-  "39": {
-    name: "NO_DEBT_OF_SELECTED_TYPE",
-    description: "For repayment of a specific type of debt, the user needs to have debt that type"
-  },
-  "40": {
-    name: "NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF",
-    description: "To repay on behalf of a user an explicit amount to repay is needed"
-  },
-  "42": {
-    name: "NO_OUTSTANDING_VARIABLE_DEBT",
-    description: "User does not have outstanding variable rate debt on this reserve"
-  },
-  "43": {
-    name: "UNDERLYING_BALANCE_ZERO",
-    description: "The underlying balance needs to be greater than 0"
-  },
-  "44": {
-    name: "INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET",
-    description: "Interest rate rebalance conditions were not met"
-  },
-  "45": {
-    name: "HEALTH_FACTOR_NOT_BELOW_THRESHOLD",
-    description: "Health factor is not below the threshold"
-  },
-  "46": {
-    name: "COLLATERAL_CANNOT_BE_LIQUIDATED",
-    description: "The collateral chosen cannot be liquidated"
-  },
-  "47": {
-    name: "SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER",
-    description: "User did not borrow the specified currency"
-  },
-  "49": {
-    name: "INCONSISTENT_FLASHLOAN_PARAMS",
-    description: "Inconsistent flashloan parameters"
-  },
-  "50": { name: "BORROW_CAP_EXCEEDED", description: "Borrow cap is exceeded" },
-  "51": { name: "SUPPLY_CAP_EXCEEDED", description: "Supply cap is exceeded" },
-  "52": {
-    name: "UNBACKED_MINT_CAP_EXCEEDED",
-    description: "Unbacked mint cap is exceeded"
-  },
-  "53": {
-    name: "DEBT_CEILING_EXCEEDED",
-    description: "Debt ceiling is exceeded"
-  },
-  "54": {
-    name: "UNDERLYING_CLAIMABLE_RIGHTS_NOT_ZERO",
-    description: "Claimable rights over underlying not zero (aToken supply or accruedToTreasury)"
-  },
-  "56": {
-    name: "VARIABLE_DEBT_SUPPLY_NOT_ZERO",
-    description: "Variable debt supply is not zero"
-  },
-  "57": { name: "LTV_VALIDATION_FAILED", description: "Ltv validation failed" },
-  "58": {
-    name: "INCONSISTENT_EMODE_CATEGORY",
-    description: "Inconsistent eMode category"
-  },
-  "59": {
-    name: "PRICE_ORACLE_SENTINEL_CHECK_FAILED",
-    description: "Price oracle sentinel validation failed"
-  },
-  "60": {
-    name: "ASSET_NOT_BORROWABLE_IN_ISOLATION",
-    description: "Asset is not borrowable in isolation mode"
-  },
-  "61": {
-    name: "RESERVE_ALREADY_INITIALIZED",
-    description: "Reserve has already been initialized"
-  },
-  "62": {
-    name: "USER_IN_ISOLATION_MODE_OR_LTV_ZERO",
-    description: "User is in isolation mode or ltv is zero"
-  },
-  "63": {
-    name: "INVALID_LTV",
-    description: "Invalid ltv parameter for the reserve"
-  },
-  "64": {
-    name: "INVALID_LIQ_THRESHOLD",
-    description: "Invalid liquidity threshold parameter for the reserve"
-  },
-  "65": {
-    name: "INVALID_LIQ_BONUS",
-    description: "Invalid liquidity bonus parameter for the reserve"
-  },
-  "66": {
-    name: "INVALID_DECIMALS",
-    description: "Invalid decimals parameter of the underlying asset of the reserve"
-  },
-  "67": {
-    name: "INVALID_RESERVE_FACTOR",
-    description: "Invalid reserve factor parameter for the reserve"
-  },
-  "68": {
-    name: "INVALID_BORROW_CAP",
-    description: "Invalid borrow cap for the reserve"
-  },
-  "69": {
-    name: "INVALID_SUPPLY_CAP",
-    description: "Invalid supply cap for the reserve"
-  },
-  "70": {
-    name: "INVALID_LIQUIDATION_PROTOCOL_FEE",
-    description: "Invalid liquidation protocol fee for the reserve"
-  },
-  "71": {
-    name: "INVALID_EMODE_CATEGORY",
-    description: "Invalid eMode category for the reserve"
-  },
-  "72": {
-    name: "INVALID_UNBACKED_MINT_CAP",
-    description: "Invalid unbacked mint cap for the reserve"
-  },
-  "73": {
-    name: "INVALID_DEBT_CEILING",
-    description: "Invalid debt ceiling for the reserve"
-  },
-  "74": { name: "INVALID_RESERVE_INDEX", description: "Invalid reserve index" },
-  "75": {
-    name: "ACL_ADMIN_CANNOT_BE_ZERO",
-    description: "ACL admin cannot be set to the zero address"
-  },
-  "76": {
-    name: "INCONSISTENT_PARAMS_LENGTH",
-    description: "Array parameters that should be equal length are not"
-  },
-  "77": {
-    name: "ZERO_ADDRESS_NOT_VALID",
-    description: "Zero address not valid"
-  },
-  "78": { name: "INVALID_EXPIRATION", description: "Invalid expiration" },
-  "79": { name: "INVALID_SIGNATURE", description: "Invalid signature" },
-  "80": {
-    name: "OPERATION_NOT_SUPPORTED",
-    description: "Operation not supported"
-  },
-  "81": {
-    name: "DEBT_CEILING_NOT_ZERO",
-    description: "Debt ceiling is not zero"
-  },
-  "82": { name: "ASSET_NOT_LISTED", description: "Asset is not listed" },
-  "83": {
-    name: "INVALID_OPTIMAL_USAGE_RATIO",
-    description: "Invalid optimal usage ratio"
-  },
-  "85": {
-    name: "UNDERLYING_CANNOT_BE_RESCUED",
-    description: "The underlying asset cannot be rescued"
-  },
-  "86": {
-    name: "ADDRESSES_PROVIDER_ALREADY_ADDED",
-    description: "Reserve has already been added to reserve list"
-  },
-  "87": {
-    name: "POOL_ADDRESSES_DO_NOT_MATCH",
-    description: "The token implementation pool address and the pool address provided by the initializing pool do not match"
-  },
-  "89": {
-    name: "SILOED_BORROWING_VIOLATION",
-    description: "User is trying to borrow multiple assets including a siloed one"
-  },
-  "90": {
-    name: "RESERVE_DEBT_NOT_ZERO",
-    description: "The total debt of the reserve needs to be 0"
-  },
-  "91": {
-    name: "FLASHLOAN_DISABLED",
-    description: "FlashLoaning for this asset is disabled"
-  },
-  "92": {
-    name: "INVALID_MAX_RATE",
-    description: "The expect maximum borrow rate is invalid"
-  },
-  "93": {
-    name: "WITHDRAW_TO_ATOKEN",
-    description: "Withdrawing to the aToken is not allowed"
-  },
-  "94": {
-    name: "SUPPLY_TO_ATOKEN",
-    description: "Supplying to the aToken is not allowed"
-  },
-  "95": {
-    name: "SLOPE_2_MUST_BE_GTE_SLOPE_1",
-    description: "Variable interest rate slope 2 can not be lower than slope 1"
-  },
-  "96": {
-    name: "CALLER_NOT_RISK_OR_POOL_OR_EMERGENCY_ADMIN",
-    description: "The caller of the function is not a risk, pool or emergency admin"
-  },
-  "97": {
-    name: "LIQUIDATION_GRACE_SENTINEL_CHECK_FAILED",
-    description: "Liquidation grace sentinel validation failed"
-  },
-  "98": {
-    name: "INVALID_GRACE_PERIOD",
-    description: "Grace period above a valid range"
-  },
-  "99": {
-    name: "INVALID_FREEZE_STATE",
-    description: "Reserve is already in the passed freeze state"
-  },
-  "100": {
-    name: "NOT_BORROWABLE_IN_EMODE",
-    description: "Asset not borrowable in eMode"
-  }
+const AAVE_ERROR_CODES = {
+	"1": {
+		name: "CALLER_NOT_POOL_ADMIN",
+		description: "The caller of the function is not a pool admin"
+	},
+	"2": {
+		name: "CALLER_NOT_EMERGENCY_ADMIN",
+		description: "The caller of the function is not an emergency admin"
+	},
+	"3": {
+		name: "CALLER_NOT_POOL_OR_EMERGENCY_ADMIN",
+		description: "The caller of the function is not a pool or emergency admin"
+	},
+	"4": {
+		name: "CALLER_NOT_RISK_OR_POOL_ADMIN",
+		description: "The caller of the function is not a risk or pool admin"
+	},
+	"5": {
+		name: "CALLER_NOT_ASSET_LISTING_OR_POOL_ADMIN",
+		description: "The caller of the function is not an asset listing or pool admin"
+	},
+	"6": {
+		name: "CALLER_NOT_BRIDGE",
+		description: "The caller of the function is not a bridge"
+	},
+	"7": {
+		name: "ADDRESSES_PROVIDER_NOT_REGISTERED",
+		description: "Pool addresses provider is not registered"
+	},
+	"8": {
+		name: "INVALID_ADDRESSES_PROVIDER_ID",
+		description: "Invalid id for the pool addresses provider"
+	},
+	"9": {
+		name: "NOT_CONTRACT",
+		description: "Address is not a contract"
+	},
+	"10": {
+		name: "CALLER_NOT_POOL_CONFIGURATOR",
+		description: "The caller of the function is not the pool configurator"
+	},
+	"11": {
+		name: "CALLER_NOT_ATOKEN",
+		description: "The caller of the function is not an AToken"
+	},
+	"12": {
+		name: "INVALID_ADDRESSES_PROVIDER",
+		description: "The address of the pool addresses provider is invalid"
+	},
+	"13": {
+		name: "INVALID_FLASHLOAN_EXECUTOR_RETURN",
+		description: "Invalid return value of the flashloan executor function"
+	},
+	"14": {
+		name: "RESERVE_ALREADY_ADDED",
+		description: "Reserve has already been added to reserve list"
+	},
+	"15": {
+		name: "NO_MORE_RESERVES_ALLOWED",
+		description: "Maximum amount of reserves in the pool reached"
+	},
+	"16": {
+		name: "EMODE_CATEGORY_RESERVED",
+		description: "Zero eMode category is reserved for volatile heterogeneous assets"
+	},
+	"17": {
+		name: "INVALID_EMODE_CATEGORY_ASSIGNMENT",
+		description: "Invalid eMode category assignment to asset"
+	},
+	"18": {
+		name: "RESERVE_LIQUIDITY_NOT_ZERO",
+		description: "The liquidity of the reserve needs to be 0"
+	},
+	"19": {
+		name: "FLASHLOAN_PREMIUM_INVALID",
+		description: "Invalid flashloan premium"
+	},
+	"20": {
+		name: "INVALID_RESERVE_PARAMS",
+		description: "Invalid risk parameters for the reserve"
+	},
+	"21": {
+		name: "INVALID_EMODE_CATEGORY_PARAMS",
+		description: "Invalid risk parameters for the eMode category"
+	},
+	"22": {
+		name: "BRIDGE_PROTOCOL_FEE_INVALID",
+		description: "Invalid bridge protocol fee"
+	},
+	"23": {
+		name: "CALLER_MUST_BE_POOL",
+		description: "The caller of this function must be a pool"
+	},
+	"24": {
+		name: "INVALID_MINT_AMOUNT",
+		description: "Invalid amount to mint"
+	},
+	"25": {
+		name: "INVALID_BURN_AMOUNT",
+		description: "Invalid amount to burn"
+	},
+	"26": {
+		name: "INVALID_AMOUNT",
+		description: "Amount must be greater than 0"
+	},
+	"27": {
+		name: "RESERVE_INACTIVE",
+		description: "Action requires an active reserve"
+	},
+	"28": {
+		name: "RESERVE_FROZEN",
+		description: "Action cannot be performed because the reserve is frozen"
+	},
+	"29": {
+		name: "RESERVE_PAUSED",
+		description: "Action cannot be performed because the reserve is paused"
+	},
+	"30": {
+		name: "BORROWING_NOT_ENABLED",
+		description: "Borrowing is not enabled"
+	},
+	"32": {
+		name: "NOT_ENOUGH_AVAILABLE_USER_BALANCE",
+		description: "User cannot withdraw more than the available balance"
+	},
+	"33": {
+		name: "INVALID_INTEREST_RATE_MODE_SELECTED",
+		description: "Invalid interest rate mode selected"
+	},
+	"34": {
+		name: "COLLATERAL_BALANCE_IS_ZERO",
+		description: "The collateral balance is 0"
+	},
+	"35": {
+		name: "HEALTH_FACTOR_LOWER_THAN_LIQUIDATION_THRESHOLD",
+		description: "Health factor is lesser than the liquidation threshold"
+	},
+	"36": {
+		name: "COLLATERAL_CANNOT_COVER_NEW_BORROW",
+		description: "There is not enough collateral to cover a new borrow"
+	},
+	"37": {
+		name: "COLLATERAL_SAME_AS_BORROWING_CURRENCY",
+		description: "Collateral is (mostly) the same currency that is being borrowed"
+	},
+	"39": {
+		name: "NO_DEBT_OF_SELECTED_TYPE",
+		description: "For repayment of a specific type of debt, the user needs to have debt that type"
+	},
+	"40": {
+		name: "NO_EXPLICIT_AMOUNT_TO_REPAY_ON_BEHALF",
+		description: "To repay on behalf of a user an explicit amount to repay is needed"
+	},
+	"42": {
+		name: "NO_OUTSTANDING_VARIABLE_DEBT",
+		description: "User does not have outstanding variable rate debt on this reserve"
+	},
+	"43": {
+		name: "UNDERLYING_BALANCE_ZERO",
+		description: "The underlying balance needs to be greater than 0"
+	},
+	"44": {
+		name: "INTEREST_RATE_REBALANCE_CONDITIONS_NOT_MET",
+		description: "Interest rate rebalance conditions were not met"
+	},
+	"45": {
+		name: "HEALTH_FACTOR_NOT_BELOW_THRESHOLD",
+		description: "Health factor is not below the threshold"
+	},
+	"46": {
+		name: "COLLATERAL_CANNOT_BE_LIQUIDATED",
+		description: "The collateral chosen cannot be liquidated"
+	},
+	"47": {
+		name: "SPECIFIED_CURRENCY_NOT_BORROWED_BY_USER",
+		description: "User did not borrow the specified currency"
+	},
+	"49": {
+		name: "INCONSISTENT_FLASHLOAN_PARAMS",
+		description: "Inconsistent flashloan parameters"
+	},
+	"50": {
+		name: "BORROW_CAP_EXCEEDED",
+		description: "Borrow cap is exceeded"
+	},
+	"51": {
+		name: "SUPPLY_CAP_EXCEEDED",
+		description: "Supply cap is exceeded"
+	},
+	"52": {
+		name: "UNBACKED_MINT_CAP_EXCEEDED",
+		description: "Unbacked mint cap is exceeded"
+	},
+	"53": {
+		name: "DEBT_CEILING_EXCEEDED",
+		description: "Debt ceiling is exceeded"
+	},
+	"54": {
+		name: "UNDERLYING_CLAIMABLE_RIGHTS_NOT_ZERO",
+		description: "Claimable rights over underlying not zero (aToken supply or accruedToTreasury)"
+	},
+	"56": {
+		name: "VARIABLE_DEBT_SUPPLY_NOT_ZERO",
+		description: "Variable debt supply is not zero"
+	},
+	"57": {
+		name: "LTV_VALIDATION_FAILED",
+		description: "Ltv validation failed"
+	},
+	"58": {
+		name: "INCONSISTENT_EMODE_CATEGORY",
+		description: "Inconsistent eMode category"
+	},
+	"59": {
+		name: "PRICE_ORACLE_SENTINEL_CHECK_FAILED",
+		description: "Price oracle sentinel validation failed"
+	},
+	"60": {
+		name: "ASSET_NOT_BORROWABLE_IN_ISOLATION",
+		description: "Asset is not borrowable in isolation mode"
+	},
+	"61": {
+		name: "RESERVE_ALREADY_INITIALIZED",
+		description: "Reserve has already been initialized"
+	},
+	"62": {
+		name: "USER_IN_ISOLATION_MODE_OR_LTV_ZERO",
+		description: "User is in isolation mode or ltv is zero"
+	},
+	"63": {
+		name: "INVALID_LTV",
+		description: "Invalid ltv parameter for the reserve"
+	},
+	"64": {
+		name: "INVALID_LIQ_THRESHOLD",
+		description: "Invalid liquidity threshold parameter for the reserve"
+	},
+	"65": {
+		name: "INVALID_LIQ_BONUS",
+		description: "Invalid liquidity bonus parameter for the reserve"
+	},
+	"66": {
+		name: "INVALID_DECIMALS",
+		description: "Invalid decimals parameter of the underlying asset of the reserve"
+	},
+	"67": {
+		name: "INVALID_RESERVE_FACTOR",
+		description: "Invalid reserve factor parameter for the reserve"
+	},
+	"68": {
+		name: "INVALID_BORROW_CAP",
+		description: "Invalid borrow cap for the reserve"
+	},
+	"69": {
+		name: "INVALID_SUPPLY_CAP",
+		description: "Invalid supply cap for the reserve"
+	},
+	"70": {
+		name: "INVALID_LIQUIDATION_PROTOCOL_FEE",
+		description: "Invalid liquidation protocol fee for the reserve"
+	},
+	"71": {
+		name: "INVALID_EMODE_CATEGORY",
+		description: "Invalid eMode category for the reserve"
+	},
+	"72": {
+		name: "INVALID_UNBACKED_MINT_CAP",
+		description: "Invalid unbacked mint cap for the reserve"
+	},
+	"73": {
+		name: "INVALID_DEBT_CEILING",
+		description: "Invalid debt ceiling for the reserve"
+	},
+	"74": {
+		name: "INVALID_RESERVE_INDEX",
+		description: "Invalid reserve index"
+	},
+	"75": {
+		name: "ACL_ADMIN_CANNOT_BE_ZERO",
+		description: "ACL admin cannot be set to the zero address"
+	},
+	"76": {
+		name: "INCONSISTENT_PARAMS_LENGTH",
+		description: "Array parameters that should be equal length are not"
+	},
+	"77": {
+		name: "ZERO_ADDRESS_NOT_VALID",
+		description: "Zero address not valid"
+	},
+	"78": {
+		name: "INVALID_EXPIRATION",
+		description: "Invalid expiration"
+	},
+	"79": {
+		name: "INVALID_SIGNATURE",
+		description: "Invalid signature"
+	},
+	"80": {
+		name: "OPERATION_NOT_SUPPORTED",
+		description: "Operation not supported"
+	},
+	"81": {
+		name: "DEBT_CEILING_NOT_ZERO",
+		description: "Debt ceiling is not zero"
+	},
+	"82": {
+		name: "ASSET_NOT_LISTED",
+		description: "Asset is not listed"
+	},
+	"83": {
+		name: "INVALID_OPTIMAL_USAGE_RATIO",
+		description: "Invalid optimal usage ratio"
+	},
+	"85": {
+		name: "UNDERLYING_CANNOT_BE_RESCUED",
+		description: "The underlying asset cannot be rescued"
+	},
+	"86": {
+		name: "ADDRESSES_PROVIDER_ALREADY_ADDED",
+		description: "Reserve has already been added to reserve list"
+	},
+	"87": {
+		name: "POOL_ADDRESSES_DO_NOT_MATCH",
+		description: "The token implementation pool address and the pool address provided by the initializing pool do not match"
+	},
+	"89": {
+		name: "SILOED_BORROWING_VIOLATION",
+		description: "User is trying to borrow multiple assets including a siloed one"
+	},
+	"90": {
+		name: "RESERVE_DEBT_NOT_ZERO",
+		description: "The total debt of the reserve needs to be 0"
+	},
+	"91": {
+		name: "FLASHLOAN_DISABLED",
+		description: "FlashLoaning for this asset is disabled"
+	},
+	"92": {
+		name: "INVALID_MAX_RATE",
+		description: "The expect maximum borrow rate is invalid"
+	},
+	"93": {
+		name: "WITHDRAW_TO_ATOKEN",
+		description: "Withdrawing to the aToken is not allowed"
+	},
+	"94": {
+		name: "SUPPLY_TO_ATOKEN",
+		description: "Supplying to the aToken is not allowed"
+	},
+	"95": {
+		name: "SLOPE_2_MUST_BE_GTE_SLOPE_1",
+		description: "Variable interest rate slope 2 can not be lower than slope 1"
+	},
+	"96": {
+		name: "CALLER_NOT_RISK_OR_POOL_OR_EMERGENCY_ADMIN",
+		description: "The caller of the function is not a risk, pool or emergency admin"
+	},
+	"97": {
+		name: "LIQUIDATION_GRACE_SENTINEL_CHECK_FAILED",
+		description: "Liquidation grace sentinel validation failed"
+	},
+	"98": {
+		name: "INVALID_GRACE_PERIOD",
+		description: "Grace period above a valid range"
+	},
+	"99": {
+		name: "INVALID_FREEZE_STATE",
+		description: "Reserve is already in the passed freeze state"
+	},
+	"100": {
+		name: "NOT_BORROWABLE_IN_EMODE",
+		description: "Asset not borrowable in eMode"
+	}
 };
 function getAaveError(code) {
-  const err = AAVE_ERROR_CODES[code];
-  if (err) {
-    return new AaveError(code, err.name, err.description);
-  }
-  return null;
+	const err = AAVE_ERROR_CODES[code];
+	if (err) return new AaveError(code, err.name, err.description);
+	return null;
 }
 
-// src/aave-lending-plugin/populateTransaction.ts
+//#endregion
+//#region src/aave-lending-plugin/populateTransaction.ts
 async function populateTransaction(tx) {
-  let txData = null;
-  try {
-    txData = await tx.tx();
-  } catch (unknownError) {
-    const reason = typeof unknownError === "object" && unknownError !== null && "reason" in unknownError && typeof unknownError.reason === "string" ? unknownError.reason : "";
-    const errorCode = reason.split(" ").pop();
-    const aaveError = getAaveError(errorCode);
-    if (aaveError !== null) {
-      throw aaveError;
-    } else {
-      throw unknownError;
-    }
-  }
-  if (!txData) {
-    throw new Error("Failed to populate transaction");
-  }
-  return {
-    value: import_ethers2.ethers.BigNumber.from(txData.value ?? 0),
-    from: txData.from,
-    to: txData.to,
-    data: txData.data
-  };
+	let txData = null;
+	try {
+		txData = await tx.tx();
+	} catch (unknownError) {
+		const aaveError = getAaveError((typeof unknownError === "object" && unknownError !== null && "reason" in unknownError && typeof unknownError.reason === "string" ? unknownError.reason : "").split(" ").pop());
+		if (aaveError !== null) throw aaveError;
+		else throw unknownError;
+	}
+	if (!txData) throw new Error("Failed to populate transaction");
+	return {
+		value: ethers.ethers.BigNumber.from(txData.value ?? 0),
+		from: txData.from,
+		to: txData.to,
+		data: txData.data
+	};
 }
 
-// src/aave-lending-plugin/userSummary.ts
-var import_math_utils = require("@aave/math-utils");
+//#endregion
+//#region src/aave-lending-plugin/userSummary.ts
 function formatNumeric(value) {
-  const num = parseFloat(value);
-  if (Number.isInteger(num)) return num.toString();
-  return parseFloat(num.toFixed(2)).toString();
+	const num = parseFloat(value);
+	if (Number.isInteger(num)) return num.toString();
+	return parseFloat(num.toFixed(2)).toString();
 }
 var UserSummary = class {
-  reserves;
-  /**
-   * @param userReservesResponse - The response from getUserReservesHumanized.
-   * @param reservesResponse - The response from getReservesHumanized.
-   */
-  constructor(userReservesResponse, reservesResponse) {
-    const currentTimestamp = Date.now() / 1e3;
-    const formattedReserves = (0, import_math_utils.formatReserves)({
-      reserves: reservesResponse.reservesData,
-      currentTimestamp,
-      marketReferenceCurrencyDecimals: reservesResponse.baseCurrencyData.marketReferenceCurrencyDecimals,
-      marketReferencePriceInUsd: reservesResponse.baseCurrencyData.marketReferenceCurrencyPriceInUsd
-    });
-    this.reserves = (0, import_math_utils.formatUserSummary)({
-      currentTimestamp,
-      marketReferencePriceInUsd: reservesResponse.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
-      marketReferenceCurrencyDecimals: reservesResponse.baseCurrencyData.marketReferenceCurrencyDecimals,
-      userReserves: userReservesResponse.userReserves,
-      formattedReserves,
-      userEmodeCategoryId: userReservesResponse.userEmodeCategoryId
-    });
-  }
-  toHumanReadable() {
-    let output = "User Positions:\n";
-    output += `Total Liquidity (USD): ${formatNumeric(this.reserves.totalLiquidityUSD)}
-`;
-    output += `Total Collateral (USD): ${formatNumeric(this.reserves.totalCollateralUSD)}
-`;
-    output += `Total Borrows (USD): ${formatNumeric(this.reserves.totalBorrowsUSD)}
-`;
-    output += `Net Worth (USD): ${formatNumeric(this.reserves.netWorthUSD)}
-`;
-    output += `Health Factor: ${formatNumeric(this.reserves.healthFactor)}
-
-`;
-    output += "Deposits:\n";
-    for (const entry of this.reserves.userReservesData) {
-      if (parseFloat(entry.scaledATokenBalance) > 0) {
-        const underlying = entry.underlyingBalance;
-        const underlyingUSD = entry.underlyingBalanceUSD ? formatNumeric(entry.underlyingBalanceUSD) : "N/A";
-        output += `- ${entry.reserve.symbol}: ${underlying} (USD: ${underlyingUSD})
-`;
-      }
-    }
-    output += "\nLoans:\n";
-    for (const entry of this.reserves.userReservesData) {
-      const borrow = entry.totalBorrows || "0";
-      if (parseFloat(borrow) > 0) {
-        const totalBorrows = entry.totalBorrows;
-        const totalBorrowsUSD = entry.totalBorrowsUSD ? formatNumeric(entry.totalBorrowsUSD) : "N/A";
-        output += `- ${entry.reserve.symbol}: ${totalBorrows} (USD: ${totalBorrowsUSD})
-`;
-      }
-    }
-    return output;
-  }
+	reserves;
+	/**
+	* @param userReservesResponse - The response from getUserReservesHumanized.
+	* @param reservesResponse - The response from getReservesHumanized.
+	*/
+	constructor(userReservesResponse, reservesResponse) {
+		const currentTimestamp = Date.now() / 1e3;
+		const formattedReserves = (0, __aave_math_utils.formatReserves)({
+			reserves: reservesResponse.reservesData,
+			currentTimestamp,
+			marketReferenceCurrencyDecimals: reservesResponse.baseCurrencyData.marketReferenceCurrencyDecimals,
+			marketReferencePriceInUsd: reservesResponse.baseCurrencyData.marketReferenceCurrencyPriceInUsd
+		});
+		this.reserves = (0, __aave_math_utils.formatUserSummary)({
+			currentTimestamp,
+			marketReferencePriceInUsd: reservesResponse.baseCurrencyData.marketReferenceCurrencyPriceInUsd,
+			marketReferenceCurrencyDecimals: reservesResponse.baseCurrencyData.marketReferenceCurrencyDecimals,
+			userReserves: userReservesResponse.userReserves,
+			formattedReserves,
+			userEmodeCategoryId: userReservesResponse.userEmodeCategoryId
+		});
+	}
+	toHumanReadable() {
+		let output = "User Positions:\n";
+		output += `Total Liquidity (USD): ${formatNumeric(this.reserves.totalLiquidityUSD)}\n`;
+		output += `Total Collateral (USD): ${formatNumeric(this.reserves.totalCollateralUSD)}\n`;
+		output += `Total Borrows (USD): ${formatNumeric(this.reserves.totalBorrowsUSD)}\n`;
+		output += `Net Worth (USD): ${formatNumeric(this.reserves.netWorthUSD)}\n`;
+		output += `Health Factor: ${formatNumeric(this.reserves.healthFactor)}\n\n`;
+		output += "Deposits:\n";
+		for (const entry of this.reserves.userReservesData) if (parseFloat(entry.scaledATokenBalance) > 0) {
+			const underlying = entry.underlyingBalance;
+			const underlyingUSD = entry.underlyingBalanceUSD ? formatNumeric(entry.underlyingBalanceUSD) : "N/A";
+			output += `- ${entry.reserve.symbol}: ${underlying} (USD: ${underlyingUSD})\n`;
+		}
+		output += "\nLoans:\n";
+		for (const entry of this.reserves.userReservesData) {
+			const borrow = entry.totalBorrows || "0";
+			if (parseFloat(borrow) > 0) {
+				const totalBorrows = entry.totalBorrows;
+				const totalBorrowsUSD = entry.totalBorrowsUSD ? formatNumeric(entry.totalBorrowsUSD) : "N/A";
+				output += `- ${entry.reserve.symbol}: ${totalBorrows} (USD: ${totalBorrowsUSD})\n`;
+			}
+		}
+		return output;
+	}
 };
 
-// src/aave-lending-plugin/adapter.ts
-var AAVE_ETH_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+//#endregion
+//#region src/aave-lending-plugin/adapter.ts
+const AAVE_ETH_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+/**
+* AAVEAdapter is the primary class wrapping Aave V3 interactions.
+*/
 var AAVEAdapter = class {
-  chain;
-  market;
-  constructor(params) {
-    this.chain = new Chain(params.chainId, params.rpcUrl);
-    this.market = getMarket(this.chain.id);
-  }
-  /**
-   * If the token is native, return AAVE's placeholder address instead of the ember address.
-   * @param token - The token to normalize.
-   * @returns The normalized token address.
-   */
-  normalizeTokenAddress(token) {
-    return token.isNative ? AAVE_ETH_PLACEHOLDER : token.tokenUid.address;
-  }
-  async createSupplyTransaction(params) {
-    const { supplyToken: token, amount, walletAddress } = params;
-    const txs = await this.supply(
-      this.normalizeTokenAddress(token),
-      amount.toString(),
-      walletAddress
-    );
-    return {
-      transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
-    };
-  }
-  async createWithdrawTransaction(params) {
-    const { tokenToWithdraw, amount, walletAddress } = params;
-    const alphaTokenAddress = (await this.getReserves()).reservesData.find(
-      (reserve) => reserve.underlyingAsset === tokenToWithdraw.tokenUid.address
-    )?.aTokenAddress;
-    if (!alphaTokenAddress) {
-      throw new Error("No position can generate the token to withdraw");
-    }
-    const txs = await this.withdraw(alphaTokenAddress, amount, walletAddress, walletAddress);
-    return {
-      transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
-    };
-  }
-  async createBorrowTransaction(params) {
-    const { borrowToken, amount, walletAddress } = params;
-    const normalizedTokenAddress = this.normalizeTokenAddress(borrowToken);
-    const poolData = await this.getPool(normalizedTokenAddress);
-    const reservesResponse = await this.getReserves();
-    let reserveLiquidationThreshold = null;
-    for (const reserve of reservesResponse.reservesData) {
-      const token = import_ethers3.ethers.utils.getAddress(reserve.underlyingAsset);
-      if (token === normalizedTokenAddress) {
-        reserveLiquidationThreshold = reserve.reserveLiquidationThreshold;
-      }
-    }
-    if (reserveLiquidationThreshold == null) {
-      throw new Error("Reserve not found in AAVE pool for a given token");
-    }
-    const txs = await this.borrow(normalizedTokenAddress, amount.toString(), walletAddress);
-    return {
-      liquidationThreshold: reserveLiquidationThreshold,
-      currentBorrowApy: poolData.variableBorrowRate,
-      transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
-    };
-  }
-  async createRepayTransaction(params) {
-    const { repayToken, amount, walletAddress: from } = params;
-    const normalizedAsset = this.normalizeTokenAddress(repayToken);
-    const txs = await this.repay(normalizedAsset, amount.toString(), from, repayToken.decimals);
-    return {
-      transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
-    };
-  }
-  async createRepayTransactionWithATokens(params) {
-    const { repayToken, amount, walletAddress: from } = params;
-    const normalizedAsset = this.normalizeTokenAddress(repayToken);
-    const txs = await this.repayWithATokens(
-      normalizedAsset,
-      amount.toString(),
-      from,
-      repayToken.decimals
-    );
-    return {
-      transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
-    };
-  }
-  // Private Methods
-  getProvider() {
-    return this.chain.getProvider();
-  }
-  getPoolBundle() {
-    const provider = this.getProvider();
-    return new import_contract_helpers2.PoolBundle(provider, {
-      POOL: this.market.POOL,
-      WETH_GATEWAY: this.market.WETH_GATEWAY
-    });
-  }
-  getPoolDataProvider() {
-    const provider = this.getProvider();
-    const DataProviderImpl = getUiPoolDataProviderImpl(this.chain.id);
-    return new DataProviderImpl({
-      uiPoolDataProviderAddress: this.market.UI_POOL_DATA_PROVIDER,
-      provider,
-      chainId: this.chain.id
-    });
-  }
-  getPoolContract() {
-    const provider = this.getProvider();
-    return new import_contract_helpers2.Pool(provider, {
-      POOL: this.market.POOL,
-      WETH_GATEWAY: this.market.WETH_GATEWAY
-    });
-  }
-  async getPool(asset) {
-    const reservesResponse = await this.getReserves();
-    let targetAsset = asset;
-    if (asset === AAVE_ETH_PLACEHOLDER) {
-      const configuredWrappedNativeToken = this.chain.wrappedNativeTokenAddress;
-      if (!configuredWrappedNativeToken) {
-        throw new Error(`No wrapped native token configured for chain ${this.chain.id}`);
-      }
-      const wrappedNativeTokenReserve = reservesResponse.reservesData.find(
-        (r) => import_ethers3.ethers.utils.getAddress(r.underlyingAsset) === configuredWrappedNativeToken
-      );
-      if (!wrappedNativeTokenReserve) {
-        throw new Error(`Wrapped native token reserve not found for native token operations`);
-      }
-      targetAsset = wrappedNativeTokenReserve.underlyingAsset;
-    }
-    const reserve = reservesResponse.reservesData.find(
-      (r) => import_ethers3.ethers.utils.getAddress(r.underlyingAsset) === import_ethers3.ethers.utils.getAddress(targetAsset)
-    );
-    if (!reserve) {
-      throw new Error(`Asset ${asset} not found in reserves`);
-    }
-    return {
-      tokenAddress: reserve.underlyingAsset,
-      poolAddress: this.market.POOL,
-      variableBorrowRate: reserve.variableBorrowRate,
-      variableSupplyRate: reserve.liquidityRate,
-      ltv: reserve.baseLTVasCollateral,
-      availableLiquidity: reserve.availableLiquidity,
-      reserveSize: reserve.availableLiquidity
-    };
-  }
-  async getReserves() {
-    const reserves = this.getPoolDataProvider().getReservesHumanized({
-      lendingPoolAddressProvider: this.market.POOL_ADDRESSES_PROVIDER
-    });
-    return reserves;
-  }
-  async getUserSummary(params) {
-    const userSummaryResponse = await this._getUserSummary(params.walletAddress);
-    const {
-      totalLiquidityUSD,
-      totalCollateralUSD,
-      totalBorrowsUSD,
-      netWorthUSD,
-      availableBorrowsUSD,
-      currentLoanToValue,
-      currentLiquidationThreshold,
-      healthFactor,
-      userReservesData
-    } = userSummaryResponse.reserves;
-    const userReservesFormatted = [];
-    for (const {
-      reserve,
-      underlyingBalance,
-      underlyingBalanceUSD,
-      variableBorrows,
-      variableBorrowsUSD,
-      totalBorrows,
-      totalBorrowsUSD: totalBorrowsUSD2
-    } of userReservesData.filter((ur) => ur.underlyingBalanceUSD !== "0")) {
-      userReservesFormatted.push({
-        tokenUid: {
-          address: reserve.underlyingAsset,
-          chainId: this.chain.id.toString()
-        },
-        underlyingBalance,
-        underlyingBalanceUsd: underlyingBalanceUSD,
-        variableBorrows,
-        variableBorrowsUsd: variableBorrowsUSD,
-        totalBorrows,
-        totalBorrowsUsd: totalBorrowsUSD2
-      });
-    }
-    return {
-      userReserves: userReservesFormatted,
-      totalLiquidityUsd: totalLiquidityUSD,
-      totalCollateralUsd: totalCollateralUSD,
-      totalBorrowsUsd: totalBorrowsUSD,
-      netWorthUsd: netWorthUSD,
-      availableBorrowsUsd: availableBorrowsUSD,
-      currentLoanToValue,
-      currentLiquidationThreshold,
-      healthFactor
-    };
-  }
-  async _getUserSummary(userAddress) {
-    const validatedUser = import_ethers3.ethers.utils.getAddress(userAddress);
-    const poolDataProvider = this.getPoolDataProvider();
-    const reservesResponse = await this.getReserves();
-    const userReservesResponse = await poolDataProvider.getUserReservesHumanized({
-      lendingPoolAddressProvider: this.market.POOL_ADDRESSES_PROVIDER,
-      user: validatedUser
-    });
-    return new UserSummary(userReservesResponse, reservesResponse);
-  }
-  borrow(asset, amount, from) {
-    import_ethers3.ethers.utils.getAddress(asset);
-    import_ethers3.ethers.utils.getAddress(from);
-    const bundle = this.getPoolBundle();
-    const tx = bundle.borrowTxBuilder.generateTxData({
-      user: from,
-      reserve: asset,
-      amount,
-      interestRateMode: import_contract_helpers2.InterestRate.Variable
-    });
-    return Promise.resolve([tx]);
-  }
-  async createApproval({
-    asset,
-    amount_raw,
-    user,
-    spender
-  }) {
-    const bundle = this.getPoolBundle();
-    let approvalTx = null;
-    const isApprovedEnough = await bundle.erc20Service.isApproved({
-      user,
-      token: asset,
-      spender,
-      amount: amount_raw,
-      nativeDecimals: true
-    });
-    if (!isApprovedEnough) {
-      approvalTx = bundle.erc20Service.approveTxData({
-        user,
-        token: asset,
-        spender,
-        amount: amount_raw
-      });
-    }
-    return approvalTx;
-  }
-  async supply(asset, amount, from) {
-    import_ethers3.ethers.utils.getAddress(asset);
-    import_ethers3.ethers.utils.getAddress(from);
-    const bundle = this.getPoolBundle();
-    const approvalTx = await this.createApproval({
-      asset,
-      amount_raw: amount,
-      user: from,
-      spender: bundle.poolAddress
-    });
-    const tx = bundle.supplyTxBuilder.generateTxData({
-      user: from,
-      reserve: asset,
-      amount,
-      onBehalfOf: from
-    });
-    return (approvalTx ? [approvalTx] : []).concat([tx]);
-  }
-  async repay(asset, amount_formatted, from, tokenDecimals) {
-    import_ethers3.ethers.utils.getAddress(asset);
-    import_ethers3.ethers.utils.getAddress(from);
-    const bundle = this.getPoolBundle();
-    const amount = import_ethers3.utils.parseUnits(amount_formatted, tokenDecimals).toString();
-    const tx = bundle.repayTxBuilder.generateTxData({
-      user: from,
-      reserve: asset,
-      amount,
-      interestRateMode: import_contract_helpers2.InterestRate.Variable,
-      onBehalfOf: from
-    });
-    const approvalTx = await this.createApproval({
-      asset,
-      amount_raw: amount,
-      user: from,
-      spender: bundle.poolAddress
-    });
-    return (approvalTx ? [approvalTx] : []).concat([tx]);
-  }
-  async repayWithATokens(asset, amount_formatted, from, tokenDecimals) {
-    import_ethers3.ethers.utils.getAddress(asset);
-    import_ethers3.ethers.utils.getAddress(from);
-    const bundle = this.getPoolBundle();
-    const amount = import_ethers3.utils.parseUnits(amount_formatted, tokenDecimals).toString();
-    const tx = bundle.repayWithATokensTxBuilder.generateTxData({
-      user: from,
-      reserve: asset,
-      amount,
-      rateMode: import_contract_helpers2.InterestRate.Variable
-    });
-    return [tx];
-  }
-  async withdraw(asset, amount, to, from) {
-    import_ethers3.ethers.utils.getAddress(asset);
-    import_ethers3.ethers.utils.getAddress(to);
-    import_ethers3.ethers.utils.getAddress(from);
-    const pool = this.getPoolContract();
-    const txs = await pool.withdraw({
-      user: from,
-      reserve: asset,
-      amount: amount.toString()
-    });
-    if (txs.length !== 1) {
-      throw new Error("AAVEInstance.withdraw: impossible happened");
-    }
-    return [await populateTransaction(txs[0])];
-  }
+	chain;
+	market;
+	constructor(params) {
+		this.chain = new Chain(params.chainId, params.rpcUrl);
+		this.market = getMarket(this.chain.id);
+	}
+	/**
+	* If the token is native, return AAVE's placeholder address instead of the ember address.
+	* @param token - The token to normalize.
+	* @returns The normalized token address.
+	*/
+	normalizeTokenAddress(token) {
+		return token.isNative ? AAVE_ETH_PLACEHOLDER : token.tokenUid.address;
+	}
+	async createSupplyTransaction(params) {
+		const { supplyToken: token, amount, walletAddress } = params;
+		return { transactions: (await this.supply(this.normalizeTokenAddress(token), amount.toString(), walletAddress)).map((t) => transactionPlanFromEthers(this.chain.id.toString(), t)) };
+	}
+	async createWithdrawTransaction(params) {
+		const { tokenToWithdraw, amount, walletAddress } = params;
+		const alphaTokenAddress = (await this.getReserves()).reservesData.find((reserve) => reserve.underlyingAsset === tokenToWithdraw.tokenUid.address)?.aTokenAddress;
+		if (!alphaTokenAddress) throw new Error("No position can generate the token to withdraw");
+		return { transactions: (await this.withdraw(alphaTokenAddress, amount, walletAddress, walletAddress)).map((t) => transactionPlanFromEthers(this.chain.id.toString(), t)) };
+	}
+	async createBorrowTransaction(params) {
+		const { borrowToken, amount, walletAddress } = params;
+		const normalizedTokenAddress = this.normalizeTokenAddress(borrowToken);
+		const poolData = await this.getPool(normalizedTokenAddress);
+		const reservesResponse = await this.getReserves();
+		let reserveLiquidationThreshold = null;
+		for (const reserve of reservesResponse.reservesData) if (ethers.ethers.utils.getAddress(reserve.underlyingAsset) === normalizedTokenAddress) reserveLiquidationThreshold = reserve.reserveLiquidationThreshold;
+		if (reserveLiquidationThreshold == null) throw new Error("Reserve not found in AAVE pool for a given token");
+		const txs = await this.borrow(normalizedTokenAddress, amount.toString(), walletAddress);
+		return {
+			liquidationThreshold: reserveLiquidationThreshold,
+			currentBorrowApy: poolData.variableBorrowRate,
+			transactions: txs.map((t) => transactionPlanFromEthers(this.chain.id.toString(), t))
+		};
+	}
+	async createRepayTransaction(params) {
+		const { repayToken, amount, walletAddress: from } = params;
+		const normalizedAsset = this.normalizeTokenAddress(repayToken);
+		return { transactions: (await this.repay(normalizedAsset, amount.toString(), from, repayToken.decimals)).map((t) => transactionPlanFromEthers(this.chain.id.toString(), t)) };
+	}
+	async createRepayTransactionWithATokens(params) {
+		const { repayToken, amount, walletAddress: from } = params;
+		const normalizedAsset = this.normalizeTokenAddress(repayToken);
+		return { transactions: (await this.repayWithATokens(normalizedAsset, amount.toString(), from, repayToken.decimals)).map((t) => transactionPlanFromEthers(this.chain.id.toString(), t)) };
+	}
+	getProvider() {
+		return this.chain.getProvider();
+	}
+	getPoolBundle() {
+		return new __aave_contract_helpers.PoolBundle(this.getProvider(), {
+			POOL: this.market.POOL,
+			WETH_GATEWAY: this.market.WETH_GATEWAY
+		});
+	}
+	getPoolDataProvider() {
+		const provider = this.getProvider();
+		return new (getUiPoolDataProviderImpl(this.chain.id))({
+			uiPoolDataProviderAddress: this.market.UI_POOL_DATA_PROVIDER,
+			provider,
+			chainId: this.chain.id
+		});
+	}
+	getPoolContract() {
+		return new __aave_contract_helpers.Pool(this.getProvider(), {
+			POOL: this.market.POOL,
+			WETH_GATEWAY: this.market.WETH_GATEWAY
+		});
+	}
+	async getPool(asset) {
+		const reservesResponse = await this.getReserves();
+		let targetAsset = asset;
+		if (asset === AAVE_ETH_PLACEHOLDER) {
+			const configuredWrappedNativeToken = this.chain.wrappedNativeTokenAddress;
+			if (!configuredWrappedNativeToken) throw new Error(`No wrapped native token configured for chain ${this.chain.id}`);
+			const wrappedNativeTokenReserve = reservesResponse.reservesData.find((r) => ethers.ethers.utils.getAddress(r.underlyingAsset) === configuredWrappedNativeToken);
+			if (!wrappedNativeTokenReserve) throw new Error(`Wrapped native token reserve not found for native token operations`);
+			targetAsset = wrappedNativeTokenReserve.underlyingAsset;
+		}
+		const reserve = reservesResponse.reservesData.find((r) => ethers.ethers.utils.getAddress(r.underlyingAsset) === ethers.ethers.utils.getAddress(targetAsset));
+		if (!reserve) throw new Error(`Asset ${asset} not found in reserves`);
+		return {
+			tokenAddress: reserve.underlyingAsset,
+			poolAddress: this.market.POOL,
+			variableBorrowRate: reserve.variableBorrowRate,
+			variableSupplyRate: reserve.liquidityRate,
+			ltv: reserve.baseLTVasCollateral,
+			availableLiquidity: reserve.availableLiquidity,
+			reserveSize: reserve.availableLiquidity
+		};
+	}
+	async getReserves() {
+		return this.getPoolDataProvider().getReservesHumanized({ lendingPoolAddressProvider: this.market.POOL_ADDRESSES_PROVIDER });
+	}
+	async getUserSummary(params) {
+		const { totalLiquidityUSD, totalCollateralUSD, totalBorrowsUSD, netWorthUSD, availableBorrowsUSD, currentLoanToValue, currentLiquidationThreshold, healthFactor, userReservesData } = (await this._getUserSummary(params.walletAddress)).reserves;
+		const userReservesFormatted = [];
+		for (const { reserve, underlyingBalance, underlyingBalanceUSD, variableBorrows, variableBorrowsUSD, totalBorrows, totalBorrowsUSD: totalBorrowsUSD$1 } of userReservesData.filter((ur) => ur.underlyingBalanceUSD !== "0")) userReservesFormatted.push({
+			tokenUid: {
+				address: reserve.underlyingAsset,
+				chainId: this.chain.id.toString()
+			},
+			underlyingBalance,
+			underlyingBalanceUsd: underlyingBalanceUSD,
+			variableBorrows,
+			variableBorrowsUsd: variableBorrowsUSD,
+			totalBorrows,
+			totalBorrowsUsd: totalBorrowsUSD$1
+		});
+		return {
+			userReserves: userReservesFormatted,
+			totalLiquidityUsd: totalLiquidityUSD,
+			totalCollateralUsd: totalCollateralUSD,
+			totalBorrowsUsd: totalBorrowsUSD,
+			netWorthUsd: netWorthUSD,
+			availableBorrowsUsd: availableBorrowsUSD,
+			currentLoanToValue,
+			currentLiquidationThreshold,
+			healthFactor
+		};
+	}
+	async _getUserSummary(userAddress) {
+		const validatedUser = ethers.ethers.utils.getAddress(userAddress);
+		const poolDataProvider = this.getPoolDataProvider();
+		const reservesResponse = await this.getReserves();
+		return new UserSummary(await poolDataProvider.getUserReservesHumanized({
+			lendingPoolAddressProvider: this.market.POOL_ADDRESSES_PROVIDER,
+			user: validatedUser
+		}), reservesResponse);
+	}
+	borrow(asset, amount, from) {
+		ethers.ethers.utils.getAddress(asset);
+		ethers.ethers.utils.getAddress(from);
+		const tx = this.getPoolBundle().borrowTxBuilder.generateTxData({
+			user: from,
+			reserve: asset,
+			amount,
+			interestRateMode: __aave_contract_helpers.InterestRate.Variable
+		});
+		return Promise.resolve([tx]);
+	}
+	async createApproval({ asset, amount_raw, user, spender }) {
+		const bundle = this.getPoolBundle();
+		let approvalTx = null;
+		if (!await bundle.erc20Service.isApproved({
+			user,
+			token: asset,
+			spender,
+			amount: amount_raw,
+			nativeDecimals: true
+		})) approvalTx = bundle.erc20Service.approveTxData({
+			user,
+			token: asset,
+			spender,
+			amount: amount_raw
+		});
+		return approvalTx;
+	}
+	async supply(asset, amount, from) {
+		ethers.ethers.utils.getAddress(asset);
+		ethers.ethers.utils.getAddress(from);
+		const bundle = this.getPoolBundle();
+		const approvalTx = await this.createApproval({
+			asset,
+			amount_raw: amount,
+			user: from,
+			spender: bundle.poolAddress
+		});
+		const tx = bundle.supplyTxBuilder.generateTxData({
+			user: from,
+			reserve: asset,
+			amount,
+			onBehalfOf: from
+		});
+		return (approvalTx ? [approvalTx] : []).concat([tx]);
+	}
+	async repay(asset, amount_formatted, from, tokenDecimals) {
+		ethers.ethers.utils.getAddress(asset);
+		ethers.ethers.utils.getAddress(from);
+		const bundle = this.getPoolBundle();
+		const amount = ethers.utils.parseUnits(amount_formatted, tokenDecimals).toString();
+		const tx = bundle.repayTxBuilder.generateTxData({
+			user: from,
+			reserve: asset,
+			amount,
+			interestRateMode: __aave_contract_helpers.InterestRate.Variable,
+			onBehalfOf: from
+		});
+		const approvalTx = await this.createApproval({
+			asset,
+			amount_raw: amount,
+			user: from,
+			spender: bundle.poolAddress
+		});
+		return (approvalTx ? [approvalTx] : []).concat([tx]);
+	}
+	async repayWithATokens(asset, amount_formatted, from, tokenDecimals) {
+		ethers.ethers.utils.getAddress(asset);
+		ethers.ethers.utils.getAddress(from);
+		const bundle = this.getPoolBundle();
+		const amount = ethers.utils.parseUnits(amount_formatted, tokenDecimals).toString();
+		return [bundle.repayWithATokensTxBuilder.generateTxData({
+			user: from,
+			reserve: asset,
+			amount,
+			rateMode: __aave_contract_helpers.InterestRate.Variable
+		})];
+	}
+	async withdraw(asset, amount, to, from) {
+		ethers.ethers.utils.getAddress(asset);
+		ethers.ethers.utils.getAddress(to);
+		ethers.ethers.utils.getAddress(from);
+		const txs = await this.getPoolContract().withdraw({
+			user: from,
+			reserve: asset,
+			amount: amount.toString()
+		});
+		if (txs.length !== 1) throw new Error("AAVEInstance.withdraw: impossible happened");
+		return [await populateTransaction(txs[0])];
+	}
 };
-var transactionPlanFromEthers = (chainId, tx) => {
-  return {
-    type: TransactionTypes.EVM_TX,
-    to: tx.to,
-    value: tx.value?.toString() || "0",
-    data: tx.data,
-    chainId
-  };
+const transactionPlanFromEthers = (chainId, tx) => {
+	return {
+		type: TransactionTypes.EVM_TX,
+		to: tx.to,
+		value: tx.value?.toString() || "0",
+		data: tx.data,
+		chainId
+	};
 };
 
-// src/aave-lending-plugin/index.ts
+//#endregion
+//#region src/aave-lending-plugin/index.ts
+/**
+* Get the AAVE Ember plugin.
+* @param params - Configuration parameters for the AAVEAdapter, including chainId and rpcUrl.
+* @returns The AAVE Ember plugin.
+*/
 async function getAaveEmberPlugin(params) {
-  const adapter = new AAVEAdapter(params);
-  return {
-    id: `AAVE_CHAIN_${params.chainId}`,
-    type: "lending",
-    name: `AAVE lending for ${params.chainId}`,
-    description: "Aave V3 lending protocol",
-    website: "https://aave.com",
-    x: "https://x.com/aave",
-    actions: await getAaveActions(adapter),
-    queries: {
-      getPositions: adapter.getUserSummary.bind(adapter)
-    }
-  };
+	const adapter = new AAVEAdapter(params);
+	return {
+		id: `AAVE_CHAIN_${params.chainId}`,
+		type: "lending",
+		name: `AAVE lending for ${params.chainId}`,
+		description: "Aave V3 lending protocol",
+		website: "https://aave.com",
+		x: "https://x.com/aave",
+		actions: await getAaveActions(adapter),
+		queries: { getPositions: adapter.getUserSummary.bind(adapter) }
+	};
 }
+/**
+* Get the AAVE actions for the lending protocol.
+* @param adapter - An instance of AAVEAdapter to interact with the AAVE protocol.
+* @returns An array of action definitions for the AAVE lending protocol.
+*/
 async function getAaveActions(adapter) {
-  const reservesResponse = await adapter.getReserves();
-  const underlyingAssets = reservesResponse.reservesData.map(
-    (reserve) => reserve.underlyingAsset
-  );
-  const aTokens = reservesResponse.reservesData.map((reserve) => reserve.aTokenAddress);
-  const borrowableAssets = reservesResponse.reservesData.filter((reserve) => reserve.borrowingEnabled).map((reserve) => reserve.underlyingAsset);
-  return [
-    // Supply any of the underlying assets to get aTokens
-    {
-      type: "lending-supply",
-      name: `AAVE lending pools in chain ${adapter.chain.id}`,
-      inputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: underlyingAssets
-        }
-      ]),
-      outputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: aTokens
-        }
-      ]),
-      callback: adapter.createSupplyTransaction.bind(adapter)
-    },
-    // Borrow any of the borrowable assets if you have some alpha tokens as collateral
-    {
-      type: "lending-borrow",
-      name: `AAVE borrow in chain ${adapter.chain.id}`,
-      inputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: aTokens
-        }
-      ]),
-      outputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: borrowableAssets
-        }
-      ]),
-      callback: adapter.createBorrowTransaction.bind(adapter)
-    },
-    // Repay your borrow with the underlying asset
-    {
-      type: "lending-repay",
-      name: `AAVE repay in chain ${adapter.chain.id}`,
-      inputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: borrowableAssets
-        }
-      ]),
-      // Empty output tokens as this doesn't generate any token
-      outputTokens: async () => Promise.resolve([]),
-      callback: adapter.createRepayTransaction.bind(adapter)
-    },
-    // Repay your borrow with aTokens
-    {
-      type: "lending-repay",
-      name: `AAVE repay with aTokens in chain ${adapter.chain.id}`,
-      inputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: aTokens
-        }
-      ]),
-      // Empty output tokens as this doesn't generate any token
-      outputTokens: async () => Promise.resolve([]),
-      callback: adapter.createRepayTransactionWithATokens.bind(adapter)
-    },
-    // Withdraw from your aTokens to get the underlying asset back
-    {
-      type: "lending-withdraw",
-      name: `AAVE withdraw in chain ${adapter.chain.id}`,
-      inputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: aTokens
-        }
-      ]),
-      outputTokens: async () => Promise.resolve([
-        {
-          chainId: adapter.chain.id.toString(),
-          tokens: underlyingAssets
-        }
-      ]),
-      callback: adapter.createWithdrawTransaction.bind(adapter)
-    }
-  ];
+	const reservesResponse = await adapter.getReserves();
+	const underlyingAssets = reservesResponse.reservesData.map((reserve) => reserve.underlyingAsset);
+	const aTokens = reservesResponse.reservesData.map((reserve) => reserve.aTokenAddress);
+	const borrowableAssets = reservesResponse.reservesData.filter((reserve) => reserve.borrowingEnabled).map((reserve) => reserve.underlyingAsset);
+	return [
+		{
+			type: "lending-supply",
+			name: `AAVE lending pools in chain ${adapter.chain.id}`,
+			inputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: underlyingAssets
+			}]),
+			outputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: aTokens
+			}]),
+			callback: adapter.createSupplyTransaction.bind(adapter)
+		},
+		{
+			type: "lending-borrow",
+			name: `AAVE borrow in chain ${adapter.chain.id}`,
+			inputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: aTokens
+			}]),
+			outputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: borrowableAssets
+			}]),
+			callback: adapter.createBorrowTransaction.bind(adapter)
+		},
+		{
+			type: "lending-repay",
+			name: `AAVE repay in chain ${adapter.chain.id}`,
+			inputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: borrowableAssets
+			}]),
+			outputTokens: async () => Promise.resolve([]),
+			callback: adapter.createRepayTransaction.bind(adapter)
+		},
+		{
+			type: "lending-repay",
+			name: `AAVE repay with aTokens in chain ${adapter.chain.id}`,
+			inputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: aTokens
+			}]),
+			outputTokens: async () => Promise.resolve([]),
+			callback: adapter.createRepayTransactionWithATokens.bind(adapter)
+		},
+		{
+			type: "lending-withdraw",
+			name: `AAVE withdraw in chain ${adapter.chain.id}`,
+			inputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: aTokens
+			}]),
+			outputTokens: async () => Promise.resolve([{
+				chainId: adapter.chain.id.toString(),
+				tokens: underlyingAssets
+			}]),
+			callback: adapter.createWithdrawTransaction.bind(adapter)
+		}
+	];
 }
+/**
+* Register the AAVE plugin for the specified chain configuration.
+* @param chainConfig - The chain configuration to check for AAVE support.
+* @param registry - The public Ember plugin registry to register the plugin with.
+* @returns A promise that resolves when the plugin is registered.
+*/
 function registerAave(chainConfig, registry) {
-  const supportedChains = [42161];
-  if (!supportedChains.includes(chainConfig.chainId)) {
-    return;
-  }
-  registry.registerDeferredPlugin(
-    getAaveEmberPlugin({
-      chainId: chainConfig.chainId,
-      rpcUrl: chainConfig.rpcUrl,
-      wrappedNativeToken: chainConfig.wrappedNativeToken
-    })
-  );
+	if (![42161].includes(chainConfig.chainId)) return;
+	registry.registerDeferredPlugin(getAaveEmberPlugin({
+		chainId: chainConfig.chainId,
+		rpcUrl: chainConfig.rpcUrl,
+		wrappedNativeToken: chainConfig.wrappedNativeToken
+	}));
 }
 
-// src/registry.ts
+//#endregion
+//#region src/registry.ts
+/**
+* Registry for public Ember plugins.
+*/
 var PublicEmberPluginRegistry = class {
-  plugins = [];
-  deferredPlugins = [];
-  /**
-   * Register a new Ember plugin.
-   * @param plugin The plugin to register.
-   */
-  registerPlugin(plugin) {
-    this.plugins.push(plugin);
-  }
-  /**
-   * Register a new deferred Ember plugin.
-   * @param pluginPromise The promise resolving to the plugin to register.
-   */
-  registerDeferredPlugin(pluginPromise) {
-    this.deferredPlugins.push(pluginPromise);
-  }
-  /**
-   * Iterator for the registered Ember plugins.
-   */
-  async *getPlugins() {
-    yield* this.plugins;
-    for (const pluginPromise of this.deferredPlugins) {
-      const plugin = await pluginPromise;
-      this.registerPlugin(plugin);
-      yield plugin;
-    }
-    this.deferredPlugins = [];
-  }
-  get emberPlugins() {
-    return this.plugins;
-  }
+	plugins = [];
+	deferredPlugins = [];
+	/**
+	* Register a new Ember plugin.
+	* @param plugin The plugin to register.
+	*/
+	registerPlugin(plugin) {
+		this.plugins.push(plugin);
+	}
+	/**
+	* Register a new deferred Ember plugin.
+	* @param pluginPromise The promise resolving to the plugin to register.
+	*/
+	registerDeferredPlugin(pluginPromise) {
+		this.deferredPlugins.push(pluginPromise);
+	}
+	/**
+	* Iterator for the registered Ember plugins.
+	*/
+	async *getPlugins() {
+		yield* this.plugins;
+		for (const pluginPromise of this.deferredPlugins) {
+			const plugin = await pluginPromise;
+			this.registerPlugin(plugin);
+			yield plugin;
+		}
+		this.deferredPlugins = [];
+	}
+	get emberPlugins() {
+		return this.plugins;
+	}
 };
 
-// src/index.ts
+//#endregion
+//#region src/index.ts
+/**
+* Initialize the public Ember plugin registry.
+* @returns The initialized public Ember plugin registry with registered plugins.
+*/
 function initializePublicRegistry(chainConfigs) {
-  const registry = new PublicEmberPluginRegistry();
-  for (const chainConfig of chainConfigs) {
-    registerAave(chainConfig, registry);
-  }
-  return registry;
+	const registry = new PublicEmberPluginRegistry();
+	for (const chainConfig of chainConfigs) registerAave(chainConfig, registry);
+	return registry;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BorrowTokensRequestSchema,
-  BorrowTokensResponseSchema,
-  ChainSchema,
-  ChainTypeSchema,
-  ClosePerpetualsOrdersRequestSchema,
-  ClosePerpetualsOrdersResponseSchema,
-  CreatePerpetualsPositionRequestSchema,
-  CreatePerpetualsPositionResponseSchema,
-  DecreasePositionSwapTypeSchema,
-  FeeBreakdownSchema,
-  GetLiquidityPoolsResponseSchema,
-  GetPerpetualsMarketsOrdersRequestSchema,
-  GetPerpetualsMarketsOrdersResponseSchema,
-  GetPerpetualsMarketsPositionsRequestSchema,
-  GetPerpetualsMarketsPositionsResponseSchema,
-  GetPerpetualsMarketsRequestSchema,
-  GetPerpetualsMarketsResponseSchema,
-  GetWalletLendingPositionsRequestSchema,
-  GetWalletLendingPositionsResponseSchema,
-  GetWalletLiquidityPositionsRequestSchema,
-  GetWalletLiquidityPositionsResponseSchema,
-  LendTokenDetailSchema,
-  LimitedLiquidityProvisionRangeSchema,
-  LiquidityPayTokensSchema,
-  LiquidityPoolSchema,
-  LiquidityPoolTokens,
-  LiquidityPositionRangeSchema,
-  LiquidityPositionSchema,
-  LiquidityProvisionRangeSchema,
-  LiquiditySuppliedTokenSchema,
-  OrderSchema,
-  OrderTypeSchema,
-  OrdersDataSchema,
-  PerpetualMarketSchema,
-  PositionSchema,
-  PositionSideSchema,
-  PositionsDataSchema,
-  ProviderTrackingInfoSchema,
-  ProviderTrackingStatusSchema,
-  PublicEmberPluginRegistry,
-  RepayTokensRequestSchema,
-  RepayTokensResponseSchema,
-  SupplyLiquidityRequestSchema,
-  SupplyLiquidityResponseSchema,
-  SupplyTokensRequestSchema,
-  SupplyTokensResponseSchema,
-  SwapEstimationSchema,
-  SwapTokensRequestSchema,
-  SwapTokensResponseSchema,
-  TokenIdentifierSchema,
-  TokenSchema,
-  TransactionPlanErrorSchema,
-  TransactionPlanSchema,
-  TransactionTypeSchema,
-  TransactionTypes,
-  WithdrawLiquidityRequestSchema,
-  WithdrawLiquidityResponseSchema,
-  WithdrawTokensRequestSchema,
-  WithdrawTokensResponseSchema,
-  initializePublicRegistry
-});
+
+//#endregion
+exports.BorrowTokensRequestSchema = BorrowTokensRequestSchema;
+exports.BorrowTokensResponseSchema = BorrowTokensResponseSchema;
+exports.ChainSchema = ChainSchema;
+exports.ChainTypeSchema = ChainTypeSchema;
+exports.ClosePerpetualsOrdersRequestSchema = ClosePerpetualsOrdersRequestSchema;
+exports.ClosePerpetualsOrdersResponseSchema = ClosePerpetualsOrdersResponseSchema;
+exports.CreatePerpetualsPositionRequestSchema = CreatePerpetualsPositionRequestSchema;
+exports.CreatePerpetualsPositionResponseSchema = CreatePerpetualsPositionResponseSchema;
+exports.DecreasePositionSwapTypeSchema = DecreasePositionSwapTypeSchema;
+exports.FeeBreakdownSchema = FeeBreakdownSchema;
+exports.GetLiquidityPoolsResponseSchema = GetLiquidityPoolsResponseSchema;
+exports.GetPerpetualsMarketsOrdersRequestSchema = GetPerpetualsMarketsOrdersRequestSchema;
+exports.GetPerpetualsMarketsOrdersResponseSchema = GetPerpetualsMarketsOrdersResponseSchema;
+exports.GetPerpetualsMarketsPositionsRequestSchema = GetPerpetualsMarketsPositionsRequestSchema;
+exports.GetPerpetualsMarketsPositionsResponseSchema = GetPerpetualsMarketsPositionsResponseSchema;
+exports.GetPerpetualsMarketsRequestSchema = GetPerpetualsMarketsRequestSchema;
+exports.GetPerpetualsMarketsResponseSchema = GetPerpetualsMarketsResponseSchema;
+exports.GetWalletLendingPositionsRequestSchema = GetWalletLendingPositionsRequestSchema;
+exports.GetWalletLendingPositionsResponseSchema = GetWalletLendingPositionsResponseSchema;
+exports.GetWalletLiquidityPositionsRequestSchema = GetWalletLiquidityPositionsRequestSchema;
+exports.GetWalletLiquidityPositionsResponseSchema = GetWalletLiquidityPositionsResponseSchema;
+exports.LendTokenDetailSchema = LendTokenDetailSchema;
+exports.LimitedLiquidityProvisionRangeSchema = LimitedLiquidityProvisionRangeSchema;
+exports.LiquidityPayTokensSchema = LiquidityPayTokensSchema;
+exports.LiquidityPoolSchema = LiquidityPoolSchema;
+exports.LiquidityPoolTokens = LiquidityPoolTokens;
+exports.LiquidityPositionRangeSchema = LiquidityPositionRangeSchema;
+exports.LiquidityPositionSchema = LiquidityPositionSchema;
+exports.LiquidityProvisionRangeSchema = LiquidityProvisionRangeSchema;
+exports.LiquiditySuppliedTokenSchema = LiquiditySuppliedTokenSchema;
+exports.OrderSchema = OrderSchema;
+exports.OrderTypeSchema = OrderTypeSchema;
+exports.OrdersDataSchema = OrdersDataSchema;
+exports.PerpetualMarketSchema = PerpetualMarketSchema;
+exports.PositionSchema = PositionSchema;
+exports.PositionSideSchema = PositionSideSchema;
+exports.PositionsDataSchema = PositionsDataSchema;
+exports.ProviderTrackingInfoSchema = ProviderTrackingInfoSchema;
+exports.ProviderTrackingStatusSchema = ProviderTrackingStatusSchema;
+exports.PublicEmberPluginRegistry = PublicEmberPluginRegistry;
+exports.RepayTokensRequestSchema = RepayTokensRequestSchema;
+exports.RepayTokensResponseSchema = RepayTokensResponseSchema;
+exports.SupplyLiquidityRequestSchema = SupplyLiquidityRequestSchema;
+exports.SupplyLiquidityResponseSchema = SupplyLiquidityResponseSchema;
+exports.SupplyTokensRequestSchema = SupplyTokensRequestSchema;
+exports.SupplyTokensResponseSchema = SupplyTokensResponseSchema;
+exports.SwapEstimationSchema = SwapEstimationSchema;
+exports.SwapTokensRequestSchema = SwapTokensRequestSchema;
+exports.SwapTokensResponseSchema = SwapTokensResponseSchema;
+exports.TokenIdentifierSchema = TokenIdentifierSchema;
+exports.TokenSchema = TokenSchema;
+exports.TransactionPlanErrorSchema = TransactionPlanErrorSchema;
+exports.TransactionPlanSchema = TransactionPlanSchema;
+exports.TransactionTypeSchema = TransactionTypeSchema;
+exports.TransactionTypes = TransactionTypes;
+exports.WithdrawLiquidityRequestSchema = WithdrawLiquidityRequestSchema;
+exports.WithdrawLiquidityResponseSchema = WithdrawLiquidityResponseSchema;
+exports.WithdrawTokensRequestSchema = WithdrawTokensRequestSchema;
+exports.WithdrawTokensResponseSchema = WithdrawTokensResponseSchema;
+exports.initializePublicRegistry = initializePublicRegistry;
 //# sourceMappingURL=index.cjs.map