@emberai/onchain-actions-registry 1.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,1433 @@
+// src/aave-lending-plugin/adapter.ts
+import {
+  Pool,
+  PoolBundle,
+  InterestRate
+} from "@aave/contract-helpers";
+import { ethers as ethers3, utils } from "ethers";
+
+// src/core/schemas/core.ts
+import { z as z2 } from "zod";
+
+// src/core/schemas/enums.ts
+import { z } from "zod";
+var ChainTypeSchema = z.enum(["UNSPECIFIED", "EVM", "SOLANA", "COSMOS"]);
+var TransactionTypes = {
+  TRANSACTION_TYPE_UNSPECIFIED: "TRANSACTION_TYPE_UNSPECIFIED",
+  EVM_TX: "EVM_TX",
+  SOLANA_TX: "SOLANA_TX"
+};
+var TransactionTypeSchema = z.enum(
+  Object.values(TransactionTypes)
+);
+
+// src/core/schemas/core.ts
+var TokenIdentifierSchema = z2.object({
+  chainId: z2.string(),
+  address: z2.string()
+});
+var TokenSchema = z2.object({
+  tokenUid: TokenIdentifierSchema,
+  name: z2.string(),
+  symbol: z2.string(),
+  isNative: z2.boolean(),
+  decimals: z2.number().int(),
+  iconUri: z2.string().nullish(),
+  isVetted: z2.boolean()
+});
+var ChainSchema = z2.object({
+  chainId: z2.string(),
+  type: ChainTypeSchema,
+  iconUri: z2.string(),
+  nativeToken: TokenSchema,
+  httpRpcUrl: z2.string(),
+  name: z2.string(),
+  blockExplorerUrls: z2.array(z2.string())
+});
+var FeeBreakdownSchema = z2.object({
+  serviceFee: z2.string(),
+  slippageCost: z2.string(),
+  total: z2.string(),
+  feeDenomination: z2.string()
+});
+var TransactionPlanSchema = z2.object({
+  type: TransactionTypeSchema,
+  to: z2.string(),
+  data: z2.string(),
+  value: z2.string(),
+  chainId: z2.string()
+});
+var TransactionPlanErrorSchema = z2.object({
+  code: z2.string(),
+  message: z2.string(),
+  details: z2.record(z2.string(), z2.string())
+});
+var ProviderTrackingInfoSchema = z2.object({
+  requestId: z2.string(),
+  providerName: z2.string(),
+  explorerUrl: z2.string()
+});
+var SwapEstimationSchema = z2.object({
+  effectivePrice: z2.string(),
+  timeEstimate: z2.string(),
+  expiration: z2.string()
+});
+var ProviderTrackingStatusSchema = z2.object({
+  requestId: z2.string(),
+  transactionId: z2.string(),
+  providerName: z2.string(),
+  explorerUrl: z2.string(),
+  status: z2.string()
+});
+
+// src/core/schemas/lending.ts
+import { z as z3 } from "zod";
+var BorrowTokensRequestSchema = z3.object({
+  borrowToken: TokenSchema,
+  amount: z3.bigint(),
+  walletAddress: z3.string()
+});
+var BorrowTokensResponseSchema = z3.object({
+  currentBorrowApy: z3.string(),
+  liquidationThreshold: z3.string(),
+  feeBreakdown: FeeBreakdownSchema.optional(),
+  transactions: z3.array(TransactionPlanSchema)
+});
+var RepayTokensRequestSchema = z3.object({
+  repayToken: TokenSchema,
+  amount: z3.bigint(),
+  walletAddress: z3.string()
+});
+var RepayTokensResponseSchema = z3.object({
+  feeBreakdown: FeeBreakdownSchema.optional(),
+  transactions: z3.array(TransactionPlanSchema)
+});
+var SupplyTokensRequestSchema = z3.object({
+  supplyToken: TokenSchema,
+  amount: z3.bigint(),
+  walletAddress: z3.string()
+});
+var SupplyTokensResponseSchema = z3.object({
+  feeBreakdown: FeeBreakdownSchema.optional(),
+  transactions: z3.array(TransactionPlanSchema)
+});
+var WithdrawTokensRequestSchema = z3.object({
+  tokenToWithdraw: TokenSchema,
+  amount: z3.bigint(),
+  walletAddress: z3.string()
+});
+var WithdrawTokensResponseSchema = z3.object({
+  feeBreakdown: FeeBreakdownSchema.optional(),
+  transactions: z3.array(TransactionPlanSchema)
+});
+var GetWalletLendingPositionsRequestSchema = z3.object({
+  walletAddress: z3.string()
+});
+var LendTokenDetailSchema = z3.object({
+  tokenUid: TokenIdentifierSchema,
+  underlyingBalance: z3.string(),
+  underlyingBalanceUsd: z3.string(),
+  variableBorrows: z3.string(),
+  variableBorrowsUsd: z3.string(),
+  totalBorrows: z3.string(),
+  totalBorrowsUsd: z3.string()
+});
+var GetWalletLendingPositionsResponseSchema = z3.object({
+  userReserves: z3.array(LendTokenDetailSchema),
+  totalLiquidityUsd: z3.string(),
+  totalCollateralUsd: z3.string(),
+  totalBorrowsUsd: z3.string(),
+  netWorthUsd: z3.string(),
+  availableBorrowsUsd: z3.string(),
+  currentLoanToValue: z3.string(),
+  currentLiquidationThreshold: z3.string(),
+  healthFactor: z3.string()
+});
+
+// src/core/schemas/liquidity.ts
+import { z as z4 } from "zod";
+var LimitedLiquidityProvisionRangeSchema = z4.object({
+  minPrice: z4.string(),
+  maxPrice: z4.string()
+});
+var LiquidityProvisionRangeSchema = z4.discriminatedUnion("type", [
+  z4.object({
+    type: z4.literal("full")
+  }),
+  z4.object({
+    type: z4.literal("limited"),
+    minPrice: z4.string(),
+    maxPrice: z4.string()
+  })
+]);
+var LiquidityPositionRangeSchema = z4.object({
+  fromPrice: z4.string(),
+  toPrice: z4.string()
+});
+var LiquiditySuppliedTokenSchema = z4.object({
+  tokenUid: TokenIdentifierSchema,
+  suppliedAmount: z4.string(),
+  owedTokens: z4.string()
+});
+var LiquidityPositionSchema = z4.object({
+  poolIdentifier: TokenIdentifierSchema,
+  operator: z4.string(),
+  suppliedTokens: z4.array(LiquiditySuppliedTokenSchema),
+  price: z4.string(),
+  providerId: z4.string(),
+  positionRange: LiquidityPositionRangeSchema.optional()
+});
+var LiquidityPoolTokens = z4.object({
+  tokenUid: TokenIdentifierSchema
+});
+var LiquidityPoolSchema = z4.object({
+  identifier: TokenIdentifierSchema,
+  tokens: z4.array(LiquidityPoolTokens),
+  price: z4.string(),
+  providerId: z4.string()
+});
+var LiquidityPayTokensSchema = z4.object({
+  token: TokenSchema,
+  supplyAmount: z4.bigint()
+});
+var SupplyLiquidityRequestSchema = z4.object({
+  walletAddress: z4.string(),
+  poolToken: TokenSchema,
+  payTokens: z4.array(LiquidityPayTokensSchema),
+  range: LiquidityProvisionRangeSchema.optional()
+});
+var SupplyLiquidityResponseSchema = z4.object({
+  transactions: z4.array(TransactionPlanSchema),
+  poolIdentifier: TokenIdentifierSchema
+});
+var WithdrawLiquidityRequestSchema = z4.object({
+  poolToken: TokenSchema,
+  walletAddress: z4.string()
+});
+var WithdrawLiquidityResponseSchema = z4.object({
+  transactions: z4.array(TransactionPlanSchema),
+  chainId: z4.string()
+});
+var GetWalletLiquidityPositionsRequestSchema = z4.object({
+  walletAddress: z4.string()
+});
+var GetWalletLiquidityPositionsResponseSchema = z4.object({
+  positions: z4.array(LiquidityPositionSchema)
+});
+var GetLiquidityPoolsResponseSchema = z4.object({
+  liquidityPools: z4.array(LiquidityPoolSchema)
+});
+
+// src/core/schemas/perpetuals.ts
+import { DecreasePositionSwapType, OrderType } from "@gmx-io/sdk/types/orders";
+import { z as z5 } from "zod";
+var DecreasePositionSwapTypeSchema = z5.nativeEnum(DecreasePositionSwapType);
+var PositionSideSchema = z5.union([z5.literal("long"), z5.literal("short")]);
+var PositionSchema = z5.object({
+  chainId: z5.string(),
+  key: z5.string(),
+  contractKey: z5.string(),
+  account: z5.string(),
+  marketAddress: z5.string(),
+  collateralTokenAddress: z5.string(),
+  sizeInUsd: z5.string(),
+  sizeInTokens: z5.string(),
+  collateralAmount: z5.string(),
+  pendingBorrowingFeesUsd: z5.string(),
+  increasedAtTime: z5.string(),
+  decreasedAtTime: z5.string(),
+  positionSide: PositionSideSchema,
+  isLong: z5.boolean(),
+  fundingFeeAmount: z5.string(),
+  claimableLongTokenAmount: z5.string(),
+  claimableShortTokenAmount: z5.string(),
+  isOpening: z5.boolean().optional(),
+  pnl: z5.string(),
+  positionFeeAmount: z5.string(),
+  traderDiscountAmount: z5.string(),
+  uiFeeAmount: z5.string(),
+  data: z5.string().optional()
+});
+var PositionsDataSchema = z5.array(PositionSchema);
+var OrderSchema = z5.object({
+  chainId: z5.string(),
+  key: z5.string(),
+  account: z5.string(),
+  callbackContract: z5.string(),
+  initialCollateralTokenAddress: z5.string(),
+  marketAddress: z5.string(),
+  decreasePositionSwapType: DecreasePositionSwapTypeSchema,
+  receiver: z5.string(),
+  swapPath: z5.array(z5.string()),
+  contractAcceptablePrice: z5.string(),
+  contractTriggerPrice: z5.string(),
+  callbackGasLimit: z5.string(),
+  executionFee: z5.string(),
+  initialCollateralDeltaAmount: z5.string(),
+  minOutputAmount: z5.string(),
+  sizeDeltaUsd: z5.string(),
+  updatedAtTime: z5.string(),
+  isFrozen: z5.boolean(),
+  positionSide: PositionSideSchema,
+  orderType: z5.nativeEnum(OrderType),
+  shouldUnwrapNativeToken: z5.boolean(),
+  autoCancel: z5.boolean(),
+  data: z5.string().optional(),
+  uiFeeReceiver: z5.string(),
+  validFromTime: z5.string(),
+  title: z5.string().optional()
+});
+var OrdersDataSchema = z5.array(OrderSchema);
+var CreatePerpetualsPositionRequestSchema = z5.object({
+  amount: z5.bigint(),
+  walletAddress: z5.string(),
+  chainId: z5.string(),
+  marketAddress: z5.string(),
+  payTokenAddress: z5.string(),
+  collateralTokenAddress: z5.string(),
+  referralCode: z5.string().optional(),
+  limitPrice: z5.string().optional(),
+  leverage: z5.string()
+});
+var CreatePerpetualsPositionResponseSchema = z5.object({
+  transactions: z5.array(TransactionPlanSchema)
+});
+var GetPerpetualsMarketsPositionsRequestSchema = z5.object({
+  walletAddress: z5.string().describe("User's wallet address")
+});
+var GetPerpetualsMarketsPositionsResponseSchema = z5.object({
+  positions: PositionsDataSchema
+});
+var GetPerpetualsMarketsOrdersRequestSchema = z5.object({
+  walletAddress: z5.string().describe("User's wallet address")
+});
+var GetPerpetualsMarketsOrdersResponseSchema = z5.object({
+  orders: OrdersDataSchema
+});
+var ClosePerpetualsOrdersRequestSchema = z5.object({
+  walletAddress: z5.string().describe("User's wallet address"),
+  key: z5.string()
+});
+var ClosePerpetualsOrdersResponseSchema = z5.object({
+  transactions: z5.array(TransactionPlanSchema)
+});
+var GetPerpetualsMarketsRequestSchema = z5.object({
+  chainIds: z5.array(z5.string())
+});
+var PerpetualMarketSchema = z5.object({
+  marketToken: TokenIdentifierSchema,
+  indexToken: TokenIdentifierSchema,
+  longToken: TokenIdentifierSchema,
+  shortToken: TokenIdentifierSchema,
+  longFundingFee: z5.string(),
+  shortFundingFee: z5.string(),
+  longBorrowingFee: z5.string(),
+  shortBorrowingFee: z5.string(),
+  chainId: z5.string(),
+  name: z5.string()
+});
+var GetPerpetualsMarketsResponseSchema = z5.object({
+  markets: z5.array(PerpetualMarketSchema)
+});
+
+// src/core/schemas/swap.ts
+import { z as z6 } from "zod";
+var SwapTokensRequestSchema = z6.object({
+  fromToken: TokenSchema,
+  toToken: TokenSchema,
+  amount: z6.bigint(),
+  limitPrice: z6.string().optional(),
+  slippageTolerance: z6.string().optional(),
+  expiration: z6.string().optional(),
+  recipient: z6.string()
+});
+var SwapTokensResponseSchema = z6.object({
+  fromToken: TokenSchema,
+  toToken: TokenSchema,
+  exactFromAmount: z6.string(),
+  displayFromAmount: z6.string(),
+  exactToAmount: z6.string(),
+  displayToAmount: z6.string(),
+  transactions: z6.array(TransactionPlanSchema),
+  feeBreakdown: FeeBreakdownSchema.optional(),
+  estimation: SwapEstimationSchema.optional(),
+  providerTracking: ProviderTrackingInfoSchema.optional()
+});
+
+// src/aave-lending-plugin/chain.ts
+import { ethers } from "ethers";
+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 ethers.providers.JsonRpcProvider(this.rpcUrl);
+  }
+};
+
+// src/aave-lending-plugin/dataProvider.ts
+import {
+  LegacyUiPoolDataProvider,
+  UiPoolDataProvider
+} from "@aave/contract-helpers";
+var UI_POOL_DATA_PROVIDER_INTERFACE_PER_CHAIN = {
+  11155111: LegacyUiPoolDataProvider,
+  42161: UiPoolDataProvider,
+  1: 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;
+};
+
+// src/aave-lending-plugin/market.ts
+import * as markets from "@bgd-labs/aave-address-book";
+var 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;
+};
+
+// src/aave-lending-plugin/populateTransaction.ts
+import { ethers as ethers2 } from "ethers";
+
+// 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);
+  }
+};
+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"
+  }
+};
+function getAaveError(code) {
+  const err = AAVE_ERROR_CODES[code];
+  if (err) {
+    return new AaveError(code, err.name, err.description);
+  }
+  return null;
+}
+
+// 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: ethers2.BigNumber.from(txData.value ?? 0),
+    from: txData.from,
+    to: txData.to,
+    data: txData.data
+  };
+}
+
+// src/aave-lending-plugin/userSummary.ts
+import {
+  formatReserves,
+  formatUserSummary
+} from "@aave/math-utils";
+function formatNumeric(value) {
+  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 = formatReserves({
+      reserves: reservesResponse.reservesData,
+      currentTimestamp,
+      marketReferenceCurrencyDecimals: reservesResponse.baseCurrencyData.marketReferenceCurrencyDecimals,
+      marketReferencePriceInUsd: reservesResponse.baseCurrencyData.marketReferenceCurrencyPriceInUsd
+    });
+    this.reserves = 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;
+  }
+};
+
+// src/aave-lending-plugin/adapter.ts
+var AAVE_ETH_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+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 = ethers3.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 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 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) => ethers3.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) => ethers3.utils.getAddress(r.underlyingAsset) === ethers3.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 = ethers3.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) {
+    ethers3.utils.getAddress(asset);
+    ethers3.utils.getAddress(from);
+    const bundle = this.getPoolBundle();
+    const tx = bundle.borrowTxBuilder.generateTxData({
+      user: from,
+      reserve: asset,
+      amount,
+      interestRateMode: 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) {
+    ethers3.utils.getAddress(asset);
+    ethers3.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) {
+    ethers3.utils.getAddress(asset);
+    ethers3.utils.getAddress(from);
+    const bundle = this.getPoolBundle();
+    const amount = utils.parseUnits(amount_formatted, tokenDecimals).toString();
+    const tx = bundle.repayTxBuilder.generateTxData({
+      user: from,
+      reserve: asset,
+      amount,
+      interestRateMode: 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) {
+    ethers3.utils.getAddress(asset);
+    ethers3.utils.getAddress(from);
+    const bundle = this.getPoolBundle();
+    const amount = utils.parseUnits(amount_formatted, tokenDecimals).toString();
+    const tx = bundle.repayWithATokensTxBuilder.generateTxData({
+      user: from,
+      reserve: asset,
+      amount,
+      rateMode: InterestRate.Variable
+    });
+    return [tx];
+  }
+  async withdraw(asset, amount, to, from) {
+    ethers3.utils.getAddress(asset);
+    ethers3.utils.getAddress(to);
+    ethers3.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])];
+  }
+};
+var 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
+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)
+    }
+  };
+}
+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)
+    }
+  ];
+}
+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
+    })
+  );
+}
+
+// src/registry.ts
+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;
+  }
+};
+
+// src/index.ts
+function initializePublicRegistry(chainConfigs) {
+  const registry = new PublicEmberPluginRegistry();
+  for (const chainConfig of chainConfigs) {
+    registerAave(chainConfig, registry);
+  }
+  return registry;
+}
+export {
+  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,
+  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
+};
+//# sourceMappingURL=index.js.map