@0dotxyz/p0-ts-sdk 2.0.2 → 2.1.0-alpha.0

package/dist/vendor.js

@@ -239,6 +239,10 @@ var SYSVAR_STAKE_HISTORY_ID = new PublicKey(
 new PublicKey(
   "StakeConfig11111111111111111111111111111111"
 );
+
+// src/constants/misc.consts.ts
+var HOURS_PER_YEAR = 365.25 * 24;
+BigInt("18446744073709551615").toString();
 new PublicKey("So11111111111111111111111111111111111111112");
 new PublicKey("LSTxxxnJzKDFSLr4dUkPcmCf5VyryEqzPLz5j4bpxFp");
 var USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
@@ -28260,7 +28264,880 @@ function makeUpdateSpotMarketIx({ spotMarket }) {
     spotMarketVault
   );
 }
+var JUP_LEND_PROGRAM_ID = new PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
+var JUP_LIQUIDITY_PROGRAM_ID = new PublicKey(
+  "jupeiUmn818Jg1ekPURTpr4mFo29p46vygyykFJ3wZC"
+);
+var JUP_REWARDS_PROGRAM_ID = new PublicKey("jup7TthsMgcR9Y3L277b8Eo9uboVSmu1utkuXHNUKar");
+
+// src/vendor/jup-lend/idl/jup-lend.json
+var jup_lend_default = {
+  address: "jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9",
+  metadata: {
+    name: "lending",
+    version: "0.1.0",
+    spec: "0.1.0",
+    description: "Created with Anchor"
+  },
+  instructions: [
+    {
+      name: "deposit",
+      discriminator: [242, 35, 198, 137, 82, 225, 242, 182],
+      accounts: [
+        { name: "signer", writable: true, signer: true },
+        { name: "depositor_token_account", writable: true },
+        { name: "recipient_token_account", writable: true },
+        { name: "mint", relations: ["lending", "rewards_rate_model"] },
+        { name: "lending_admin" },
+        { name: "lending", writable: true },
+        { name: "f_token_mint", writable: true, relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity", writable: true },
+        { name: "lending_supply_position_on_liquidity", writable: true },
+        { name: "rate_model" },
+        { name: "vault", writable: true },
+        { name: "liquidity", writable: true },
+        { name: "liquidity_program", writable: true, relations: ["lending_admin"] },
+        { name: "rewards_rate_model" },
+        { name: "token_program" },
+        { name: "associated_token_program", address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" },
+        { name: "system_program", address: "11111111111111111111111111111111" }
+      ],
+      args: [{ name: "assets", type: "u64" }],
+      returns: "u64"
+    },
+    {
+      name: "mint",
+      discriminator: [51, 57, 225, 47, 182, 146, 137, 166],
+      accounts: [
+        { name: "signer", writable: true, signer: true },
+        { name: "depositor_token_account", writable: true },
+        { name: "recipient_token_account", writable: true },
+        { name: "mint", relations: ["lending", "rewards_rate_model"] },
+        { name: "lending_admin" },
+        { name: "lending", writable: true },
+        { name: "f_token_mint", writable: true, relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity", writable: true },
+        { name: "lending_supply_position_on_liquidity", writable: true },
+        { name: "rate_model" },
+        { name: "vault", writable: true },
+        { name: "liquidity", writable: true },
+        { name: "liquidity_program", writable: true, relations: ["lending_admin"] },
+        { name: "rewards_rate_model" },
+        { name: "token_program" },
+        { name: "associated_token_program", address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" },
+        { name: "system_program", address: "11111111111111111111111111111111" }
+      ],
+      args: [{ name: "shares", type: "u64" }],
+      returns: "u64"
+    },
+    {
+      name: "withdraw",
+      discriminator: [183, 18, 70, 156, 148, 109, 161, 34],
+      accounts: [
+        { name: "signer", writable: true, signer: true },
+        { name: "owner_token_account", writable: true },
+        { name: "recipient_token_account", writable: true },
+        { name: "lending_admin" },
+        { name: "lending", writable: true },
+        { name: "mint", relations: ["lending", "rewards_rate_model"] },
+        { name: "f_token_mint", writable: true, relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity", writable: true },
+        { name: "lending_supply_position_on_liquidity", writable: true },
+        { name: "rate_model" },
+        { name: "vault", writable: true },
+        { name: "claim_account", writable: true },
+        { name: "liquidity", writable: true },
+        { name: "liquidity_program", writable: true, relations: ["lending_admin"] },
+        { name: "rewards_rate_model" },
+        { name: "token_program" },
+        { name: "associated_token_program", address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" },
+        { name: "system_program", address: "11111111111111111111111111111111" }
+      ],
+      args: [{ name: "amount", type: "u64" }],
+      returns: "u64"
+    },
+    {
+      name: "redeem",
+      discriminator: [184, 12, 86, 149, 70, 196, 97, 225],
+      accounts: [
+        { name: "signer", writable: true, signer: true },
+        { name: "owner_token_account", writable: true },
+        { name: "recipient_token_account", writable: true },
+        { name: "lending_admin" },
+        { name: "lending", writable: true },
+        { name: "mint", relations: ["lending", "rewards_rate_model"] },
+        { name: "f_token_mint", writable: true, relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity", writable: true },
+        { name: "lending_supply_position_on_liquidity", writable: true },
+        { name: "rate_model" },
+        { name: "vault", writable: true },
+        { name: "claim_account", writable: true },
+        { name: "liquidity", writable: true },
+        { name: "liquidity_program", writable: true, relations: ["lending_admin"] },
+        { name: "rewards_rate_model" },
+        { name: "token_program" },
+        { name: "associated_token_program", address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" },
+        { name: "system_program", address: "11111111111111111111111111111111" }
+      ],
+      args: [{ name: "shares", type: "u64" }],
+      returns: "u64"
+    },
+    {
+      name: "rebalance",
+      discriminator: [108, 158, 77, 9, 210, 52, 88, 62],
+      accounts: [
+        { name: "signer", writable: true, signer: true },
+        { name: "depositor_token_account", writable: true },
+        { name: "lending_admin" },
+        { name: "lending", writable: true },
+        { name: "mint", relations: ["lending", "rewards_rate_model"] },
+        { name: "f_token_mint", writable: true, relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity", writable: true },
+        { name: "lending_supply_position_on_liquidity", writable: true },
+        { name: "rate_model", writable: true },
+        { name: "vault", writable: true },
+        { name: "liquidity", writable: true },
+        { name: "liquidity_program", writable: true, relations: ["lending_admin"] },
+        { name: "rewards_rate_model" },
+        { name: "token_program" },
+        { name: "associated_token_program", address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL" },
+        { name: "system_program", address: "11111111111111111111111111111111" }
+      ],
+      args: []
+    },
+    {
+      name: "update_rate",
+      discriminator: [24, 225, 53, 189, 72, 212, 225, 178],
+      accounts: [
+        { name: "lending", writable: true },
+        { name: "mint", relations: ["lending", "supply_token_reserves_liquidity"] },
+        { name: "f_token_mint", relations: ["lending"] },
+        { name: "supply_token_reserves_liquidity" },
+        { name: "rewards_rate_model" }
+      ],
+      args: []
+    }
+  ],
+  accounts: [
+    { name: "Lending", discriminator: [135, 199, 82, 16, 249, 131, 182, 241] },
+    { name: "LendingAdmin", discriminator: [42, 8, 33, 220, 163, 40, 210, 5] },
+    { name: "LendingRewardsRateModel", discriminator: [166, 72, 71, 131, 172, 74, 166, 181] },
+    { name: "TokenReserve", discriminator: [21, 18, 59, 135, 120, 20, 31, 12] },
+    { name: "UserSupplyPosition", discriminator: [202, 219, 136, 118, 61, 177, 21, 146] }
+  ],
+  errors: [
+    { code: 6e3, name: "FTokenDepositInsignificant", msg: "F_TOKEN_DEPOSIT_INSIGNIFICANT" },
+    { code: 6001, name: "FTokenMinAmountOut", msg: "F_TOKEN_MIN_AMOUNT_OUT" },
+    { code: 6002, name: "FTokenMaxAmount", msg: "F_TOKEN_MAX_AMOUNT" },
+    { code: 6003, name: "FTokenInvalidParams", msg: "F_TOKEN_INVALID_PARAMS" },
+    { code: 6004, name: "FTokenRewardsRateModelAlreadySet", msg: "F_TOKEN_REWARDS_RATE_MODEL_ALREADY_SET" },
+    { code: 6005, name: "FTokenMaxAuthCountReached", msg: "F_TOKEN_MAX_AUTH_COUNT" },
+    { code: 6006, name: "FTokenLiquidityExchangePriceUnexpected", msg: "F_TOKEN_LIQUIDITY_EXCHANGE_PRICE_UNEXPECTED" },
+    { code: 6007, name: "FTokenCpiToLiquidityFailed", msg: "F_TOKEN_CPI_TO_LIQUIDITY_FAILED" },
+    { code: 6008, name: "FTokenOnlyAuth", msg: "F_TOKEN_ONLY_AUTH" },
+    { code: 6009, name: "FTokenOnlyAuthority", msg: "F_TOKEN_ONLY_AUTHORITY" },
+    { code: 6010, name: "FTokenOnlyRebalancer", msg: "F_TOKEN_ONLY_REBALANCER" },
+    { code: 6011, name: "FTokenUserSupplyPositionRequired", msg: "F_TOKEN_USER_SUPPLY_POSITION_REQUIRED" },
+    { code: 6012, name: "FTokenLiquidityProgramMismatch", msg: "F_TOKEN_LIQUIDITY_PROGRAM_MISMATCH" }
+  ],
+  types: [
+    {
+      name: "AddressBool",
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "addr", type: "pubkey" },
+          { name: "value", type: "bool" }
+        ]
+      }
+    },
+    {
+      name: "Lending",
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "mint", type: "pubkey" },
+          { name: "f_token_mint", type: "pubkey" },
+          { name: "lending_id", type: "u16" },
+          { name: "decimals", type: "u8" },
+          { name: "rewards_rate_model", type: "pubkey" },
+          { name: "liquidity_exchange_price", type: "u64" },
+          { name: "token_exchange_price", type: "u64" },
+          { name: "last_update_timestamp", type: "u64" },
+          { name: "token_reserves_liquidity", type: "pubkey" },
+          { name: "supply_position_on_liquidity", type: "pubkey" },
+          { name: "bump", type: "u8" }
+        ]
+      }
+    },
+    {
+      name: "LendingAdmin",
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "authority", type: "pubkey" },
+          { name: "liquidity_program", type: "pubkey" },
+          { name: "rebalancer", type: "pubkey" },
+          { name: "next_lending_id", type: "u16" },
+          { name: "auths", type: { vec: "pubkey" } },
+          { name: "bump", type: "u8" }
+        ]
+      }
+    },
+    {
+      name: "LendingRewardsRateModel",
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "mint", type: "pubkey" },
+          { name: "start_tvl", type: "u64" },
+          { name: "duration", type: "u64" },
+          { name: "start_time", type: "u64" },
+          { name: "yearly_reward", type: "u64" },
+          { name: "next_duration", type: "u64" },
+          { name: "next_reward_amount", type: "u64" },
+          { name: "bump", type: "u8" }
+        ]
+      }
+    },
+    {
+      name: "TokenReserve",
+      serialization: "bytemuck",
+      repr: { kind: "c", packed: true },
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "mint", type: "pubkey" },
+          { name: "vault", type: "pubkey" },
+          { name: "borrow_rate", type: "u16" },
+          { name: "fee_on_interest", type: "u16" },
+          { name: "last_utilization", type: "u16" },
+          { name: "last_update_timestamp", type: "u64" },
+          { name: "supply_exchange_price", type: "u64" },
+          { name: "borrow_exchange_price", type: "u64" },
+          { name: "max_utilization", type: "u16" },
+          { name: "total_supply_with_interest", type: "u64" },
+          { name: "total_supply_interest_free", type: "u64" },
+          { name: "total_borrow_with_interest", type: "u64" },
+          { name: "total_borrow_interest_free", type: "u64" },
+          { name: "total_claim_amount", type: "u64" },
+          { name: "interacting_protocol", type: "pubkey" },
+          { name: "interacting_timestamp", type: "u64" },
+          { name: "interacting_balance", type: "u64" }
+        ]
+      }
+    },
+    {
+      name: "UserSupplyPosition",
+      serialization: "bytemuck",
+      repr: { kind: "c", packed: true },
+      type: {
+        kind: "struct",
+        fields: [
+          { name: "protocol", type: "pubkey" },
+          { name: "mint", type: "pubkey" },
+          { name: "with_interest", type: "u8" },
+          { name: "amount", type: "u64" },
+          { name: "withdrawal_limit", type: "u128" },
+          { name: "last_update", type: "u64" },
+          { name: "expand_pct", type: "u16" },
+          { name: "expand_duration", type: "u64" },
+          { name: "base_withdrawal_limit", type: "u64" },
+          { name: "status", type: "u8" }
+        ]
+      }
+    }
+  ]
+};
+
+// src/vendor/jup-lend/idl/index.ts
+var JUP_LEND_IDL = jup_lend_default;
+
+// src/vendor/jup-lend/utils/serialize.utils.ts
+function jupLendingStateRawToDto(raw) {
+  return {
+    pubkey: raw.pubkey.toBase58(),
+    mint: raw.mint.toBase58(),
+    fTokenMint: raw.fTokenMint.toBase58(),
+    lendingId: raw.lendingId,
+    decimals: raw.decimals,
+    rewardsRateModel: raw.rewardsRateModel.toBase58(),
+    liquidityExchangePrice: raw.liquidityExchangePrice.toString(),
+    tokenExchangePrice: raw.tokenExchangePrice.toString(),
+    lastUpdateTimestamp: raw.lastUpdateTimestamp.toString(),
+    tokenReservesLiquidity: raw.tokenReservesLiquidity.toBase58(),
+    supplyPositionOnLiquidity: raw.supplyPositionOnLiquidity.toBase58()
+  };
+}
+function jupTokenReserveRawToDto(raw) {
+  return {
+    pubkey: raw.pubkey.toBase58(),
+    mint: raw.mint.toBase58(),
+    vault: raw.vault.toBase58(),
+    borrowRate: raw.borrowRate,
+    feeOnInterest: raw.feeOnInterest,
+    lastUtilization: raw.lastUtilization,
+    lastUpdateTimestamp: raw.lastUpdateTimestamp.toString(),
+    supplyExchangePrice: raw.supplyExchangePrice.toString(),
+    borrowExchangePrice: raw.borrowExchangePrice.toString(),
+    maxUtilization: raw.maxUtilization,
+    totalSupplyWithInterest: raw.totalSupplyWithInterest.toString(),
+    totalSupplyInterestFree: raw.totalSupplyInterestFree.toString(),
+    totalBorrowWithInterest: raw.totalBorrowWithInterest.toString(),
+    totalBorrowInterestFree: raw.totalBorrowInterestFree.toString(),
+    totalClaimAmount: raw.totalClaimAmount.toString(),
+    interactingProtocol: raw.interactingProtocol.toBase58(),
+    interactingTimestamp: raw.interactingTimestamp.toString(),
+    interactingBalance: raw.interactingBalance.toString()
+  };
+}
+function jupLendingRewardsRateModelRawToDto(raw) {
+  return {
+    pubkey: raw.pubkey.toBase58(),
+    mint: raw.mint.toBase58(),
+    startTvl: raw.startTvl.toString(),
+    duration: raw.duration.toString(),
+    startTime: raw.startTime.toString(),
+    yearlyReward: raw.yearlyReward.toString(),
+    nextDuration: raw.nextDuration.toString(),
+    nextRewardAmount: raw.nextRewardAmount.toString()
+  };
+}
+function jupRateModelRawToDto(raw) {
+  return {
+    pubkey: raw.pubkey.toBase58(),
+    mint: raw.mint.toBase58(),
+    version: raw.version,
+    rateAtZero: raw.rateAtZero,
+    kink1Utilization: raw.kink1Utilization,
+    rateAtKink1: raw.rateAtKink1,
+    rateAtMax: raw.rateAtMax,
+    kink2Utilization: raw.kink2Utilization,
+    rateAtKink2: raw.rateAtKink2
+  };
+}
+var JUP_LEND_ACCOUNTS_CODER = new BorshAccountsCoder(JUP_LEND_IDL);
+var lendingDiscriminator = Buffer.from([135, 199, 82, 16, 249, 131, 182, 241]);
+var lendingRewardsRateModelDiscriminator = Buffer.from([166, 72, 71, 131, 172, 74, 166, 181]);
+var rateModelDiscriminator = Buffer.from([94, 3, 203, 219, 107, 137, 4, 162]);
+function decodeJupLendingStateData(data, pubkey) {
+  if (!data.slice(0, 8).equals(lendingDiscriminator)) {
+    throw new Error("invalid Lending account discriminator");
+  }
+  const decoded = JUP_LEND_ACCOUNTS_CODER.decode("Lending", data);
+  return {
+    pubkey,
+    mint: decoded.mint,
+    fTokenMint: decoded.f_token_mint ?? decoded.fTokenMint,
+    lendingId: decoded.lending_id ?? decoded.lendingId,
+    decimals: decoded.decimals,
+    rewardsRateModel: decoded.rewards_rate_model ?? decoded.rewardsRateModel,
+    liquidityExchangePrice: decoded.liquidity_exchange_price ?? decoded.liquidityExchangePrice,
+    tokenExchangePrice: decoded.token_exchange_price ?? decoded.tokenExchangePrice,
+    lastUpdateTimestamp: decoded.last_update_timestamp ?? decoded.lastUpdateTimestamp,
+    tokenReservesLiquidity: decoded.token_reserves_liquidity ?? decoded.tokenReservesLiquidity,
+    supplyPositionOnLiquidity: decoded.supply_position_on_liquidity ?? decoded.supplyPositionOnLiquidity,
+    bump: decoded.bump
+  };
+}
+function decodeJupLendingRewardsRateModelData(data, pubkey) {
+  if (!data.slice(0, 8).equals(lendingRewardsRateModelDiscriminator)) {
+    throw new Error("invalid LendingRewardsRateModel account discriminator");
+  }
+  const decoded = JUP_LEND_ACCOUNTS_CODER.decode("LendingRewardsRateModel", data);
+  return {
+    pubkey,
+    mint: decoded.mint,
+    startTvl: decoded.start_tvl ?? decoded.startTvl,
+    duration: decoded.duration,
+    startTime: decoded.start_time ?? decoded.startTime,
+    yearlyReward: decoded.yearly_reward ?? decoded.yearlyReward,
+    nextDuration: decoded.next_duration ?? decoded.nextDuration,
+    nextRewardAmount: decoded.next_reward_amount ?? decoded.nextRewardAmount,
+    bump: decoded.bump
+  };
+}
+function decodeJupTokenReserveData(data, pubkey) {
+  let offset = 8;
+  const mint = new PublicKey(data.slice(offset, offset + 32));
+  offset += 32;
+  const vault = new PublicKey(data.slice(offset, offset + 32));
+  offset += 32;
+  const borrowRate = data.readUInt16LE(offset);
+  offset += 2;
+  const feeOnInterest = data.readUInt16LE(offset);
+  offset += 2;
+  const lastUtilization = data.readUInt16LE(offset);
+  offset += 2;
+  const lastUpdateTimestamp = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const supplyExchangePrice = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const borrowExchangePrice = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const maxUtilization = data.readUInt16LE(offset);
+  offset += 2;
+  const totalSupplyWithInterest = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const totalSupplyInterestFree = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const totalBorrowWithInterest = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const totalBorrowInterestFree = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const totalClaimAmount = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const interactingProtocol = new PublicKey(data.slice(offset, offset + 32));
+  offset += 32;
+  const interactingTimestamp = new BN2(data.slice(offset, offset + 8), "le");
+  offset += 8;
+  const interactingBalance = new BN2(data.slice(offset, offset + 8), "le");
+  return {
+    pubkey,
+    mint,
+    vault,
+    borrowRate,
+    feeOnInterest,
+    lastUtilization,
+    lastUpdateTimestamp,
+    supplyExchangePrice,
+    borrowExchangePrice,
+    maxUtilization,
+    totalSupplyWithInterest,
+    totalSupplyInterestFree,
+    totalBorrowWithInterest,
+    totalBorrowInterestFree,
+    totalClaimAmount,
+    interactingProtocol,
+    interactingTimestamp,
+    interactingBalance
+  };
+}
+function decodeJupRateModelData(data, pubkey) {
+  if (!data.slice(0, 8).equals(rateModelDiscriminator)) {
+    throw new Error("invalid RateModel account discriminator");
+  }
+  let offset = 8;
+  const mint = new PublicKey(data.slice(offset, offset + 32));
+  offset += 32;
+  const version = data.readUInt8(offset);
+  offset += 1;
+  const rateAtZero = data.readUInt16LE(offset);
+  offset += 2;
+  const kink1Utilization = data.readUInt16LE(offset);
+  offset += 2;
+  const rateAtKink1 = data.readUInt16LE(offset);
+  offset += 2;
+  const rateAtMax = data.readUInt16LE(offset);
+  offset += 2;
+  const kink2Utilization = data.readUInt16LE(offset);
+  offset += 2;
+  const rateAtKink2 = data.readUInt16LE(offset);
+  return {
+    pubkey,
+    mint,
+    version,
+    rateAtZero,
+    kink1Utilization,
+    rateAtKink1,
+    rateAtMax,
+    kink2Utilization,
+    rateAtKink2
+  };
+}
+function dtoToJupLendingStateRaw(dto) {
+  return {
+    pubkey: new PublicKey(dto.pubkey),
+    mint: new PublicKey(dto.mint),
+    fTokenMint: new PublicKey(dto.fTokenMint),
+    lendingId: dto.lendingId,
+    decimals: dto.decimals,
+    rewardsRateModel: new PublicKey(dto.rewardsRateModel),
+    liquidityExchangePrice: new BN2(dto.liquidityExchangePrice),
+    tokenExchangePrice: new BN2(dto.tokenExchangePrice),
+    lastUpdateTimestamp: new BN2(dto.lastUpdateTimestamp),
+    tokenReservesLiquidity: new PublicKey(dto.tokenReservesLiquidity),
+    supplyPositionOnLiquidity: new PublicKey(dto.supplyPositionOnLiquidity)
+  };
+}
+function dtoToJupTokenReserveRaw(dto) {
+  return {
+    pubkey: new PublicKey(dto.pubkey),
+    mint: new PublicKey(dto.mint),
+    vault: new PublicKey(dto.vault),
+    borrowRate: dto.borrowRate,
+    feeOnInterest: dto.feeOnInterest,
+    lastUtilization: dto.lastUtilization,
+    lastUpdateTimestamp: new BN2(dto.lastUpdateTimestamp),
+    supplyExchangePrice: new BN2(dto.supplyExchangePrice),
+    borrowExchangePrice: new BN2(dto.borrowExchangePrice),
+    maxUtilization: dto.maxUtilization,
+    totalSupplyWithInterest: new BN2(dto.totalSupplyWithInterest),
+    totalSupplyInterestFree: new BN2(dto.totalSupplyInterestFree),
+    totalBorrowWithInterest: new BN2(dto.totalBorrowWithInterest),
+    totalBorrowInterestFree: new BN2(dto.totalBorrowInterestFree),
+    totalClaimAmount: new BN2(dto.totalClaimAmount),
+    interactingProtocol: new PublicKey(dto.interactingProtocol),
+    interactingTimestamp: new BN2(dto.interactingTimestamp),
+    interactingBalance: new BN2(dto.interactingBalance)
+  };
+}
+function dtoToJupLendingRewardsRateModelRaw(dto) {
+  return {
+    pubkey: new PublicKey(dto.pubkey),
+    mint: new PublicKey(dto.mint),
+    startTvl: new BN2(dto.startTvl),
+    duration: new BN2(dto.duration),
+    startTime: new BN2(dto.startTime),
+    yearlyReward: new BN2(dto.yearlyReward),
+    nextDuration: new BN2(dto.nextDuration),
+    nextRewardAmount: new BN2(dto.nextRewardAmount)
+  };
+}
+function dtoToJupRateModelRaw(dto) {
+  return {
+    pubkey: new PublicKey(dto.pubkey),
+    mint: new PublicKey(dto.mint),
+    version: dto.version,
+    rateAtZero: dto.rateAtZero,
+    kink1Utilization: dto.kink1Utilization,
+    rateAtKink1: dto.rateAtKink1,
+    rateAtMax: dto.rateAtMax,
+    kink2Utilization: dto.kink2Utilization,
+    rateAtKink2: dto.rateAtKink2
+  };
+}
+var SEED_LENDING_ADMIN = "lending_admin";
+var SEED_F_TOKEN_MINT = "f_token_mint";
+var SEED_LENDING = "lending";
+var SEED_LIQUIDITY = "liquidity";
+var SEED_RESERVE = "reserve";
+var SEED_RATE_MODEL = "rate_model";
+var SEED_USER_SUPPLY_POSITION = "user_supply_position";
+var SEED_USER_CLAIM = "user_claim";
+var SEED_LENDING_REWARDS_RATE_MODEL = "lending_rewards_rate_model";
+function getAllDerivedJupLendAccounts(mint) {
+  const [fTokenMint] = deriveJupLendFTokenMint(mint);
+  const [lending] = deriveJupLendLending(mint, fTokenMint);
+  const [liquidity] = deriveJupLendLiquidity();
+  return {
+    fTokenMint,
+    lendingAdmin: deriveJupLendLendingAdmin()[0],
+    supplyTokenReservesLiquidity: deriveJupLendTokenReserve(mint)[0],
+    lendingSupplyPositionOnLiquidity: deriveJupLendLiquiditySupplyPositionPda(mint, lending)[0],
+    rateModel: deriveJupLendRateModel(mint)[0],
+    vault: deriveJupLendLiquidityVaultAta(mint, liquidity),
+    liquidity,
+    rewardsRateModel: deriveJupLendLendingRewardsRateModel(mint)[0]
+  };
+}
+function deriveJupLendLendingPdas(underlyingMint, lendingProgramId = JUP_LEND_PROGRAM_ID) {
+  const [lendingAdmin, lendingAdminBump] = deriveJupLendLendingAdmin(lendingProgramId);
+  const [fTokenMint, fTokenMintBump] = deriveJupLendFTokenMint(underlyingMint, lendingProgramId);
+  const [lending, lendingBump] = deriveJupLendLending(underlyingMint, fTokenMint, lendingProgramId);
+  return {
+    lendingAdmin,
+    lendingAdminBump,
+    fTokenMint,
+    fTokenMintBump,
+    lending,
+    lendingBump
+  };
+}
+function deriveJupLendFTokenMint(asset, lendingProgramId = JUP_LEND_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_F_TOKEN_MINT), asset.toBuffer()],
+    lendingProgramId
+  );
+}
+function deriveJupLendLending(asset, fTokenMint, lendingProgramId = JUP_LEND_PROGRAM_ID) {
+  const [_fTokenMint] = fTokenMint ? [fTokenMint] : deriveJupLendFTokenMint(asset, lendingProgramId);
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_LENDING), asset.toBuffer(), _fTokenMint.toBuffer()],
+    lendingProgramId
+  );
+}
+function deriveJupLendLendingAdmin(lendingProgramId = JUP_LEND_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(SEED_LENDING_ADMIN)], lendingProgramId);
+}
+function deriveJupLendLendingRewardsRateModel(asset, rewardsProgramId = JUP_REWARDS_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_LENDING_REWARDS_RATE_MODEL), asset.toBuffer()],
+    rewardsProgramId
+  );
+}
+function deriveJupLendTokenReserve(asset, liquidityProgramId = JUP_LIQUIDITY_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_RESERVE), asset.toBuffer()],
+    liquidityProgramId
+  );
+}
+function deriveJupLendLiquidityVaultAta(underlyingMint, liquidityPda, tokenProgramId = TOKEN_PROGRAM_ID) {
+  return getAssociatedTokenAddressSync(
+    underlyingMint,
+    liquidityPda,
+    true,
+    tokenProgramId,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+}
+function deriveJupLendRateModel(asset, liquidityProgramId = JUP_LIQUIDITY_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_RATE_MODEL), asset.toBuffer()],
+    liquidityProgramId
+  );
+}
+function deriveJupLendLiquidity(liquidityProgramId = JUP_LIQUIDITY_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(SEED_LIQUIDITY)], liquidityProgramId);
+}
+function deriveJupLendClaimAccount(owner, mint, liquidityProgramId = JUP_LIQUIDITY_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_USER_CLAIM), owner.toBuffer(), mint.toBuffer()],
+    liquidityProgramId
+  );
+}
+function deriveJupLendLiquiditySupplyPositionPda(underlyingMint, lendingPda, liquidityProgramId = JUP_LIQUIDITY_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(SEED_USER_SUPPLY_POSITION), underlyingMint.toBuffer(), lendingPda.toBuffer()],
+    liquidityProgramId
+  );
+}
+
+// src/utils/accounting.utils.ts
+var aprToApy2 = (apr, compoundingFrequency = HOURS_PER_YEAR, apyCap = 3) => Math.min((1 + apr / compoundingFrequency) ** compoundingFrequency - 1, apyCap);
+
+// src/vendor/jup-lend/utils/interest-rate.utils.ts
+var JUP_EXCHANGE_PRICES_PRECISION = new BN2("1000000000000");
+var JUP_SECONDS_PER_YEAR = new BN2(31536e3);
+var JUP_MAX_REWARDS_RATE = new BN2("50000000000000");
+function calculateJupLendTotalAssets(lendingState, fTokenTotalSupply) {
+  return lendingState.tokenExchangePrice.mul(fTokenTotalSupply).div(JUP_EXCHANGE_PRICES_PRECISION);
+}
+function calculateJupLendRewardsRate(rewardsModel, totalAssets, currentTimestamp) {
+  const defaultResult = {
+    rewardsRate: new BN2(0),
+    rewardsEnded: false,
+    rewardsStartTime: rewardsModel.startTime
+  };
+  if (rewardsModel.startTime.isZero() || rewardsModel.duration.isZero()) {
+    return defaultResult;
+  }
+  if (currentTimestamp.gt(rewardsModel.startTime.add(rewardsModel.duration))) {
+    return { ...defaultResult, rewardsEnded: true };
+  }
+  if (totalAssets.lt(rewardsModel.startTvl)) {
+    return defaultResult;
+  }
+  let rewardsRate = rewardsModel.yearlyReward.mul(new BN2(1e4)).div(totalAssets);
+  if (rewardsRate.gt(JUP_MAX_REWARDS_RATE)) {
+    rewardsRate = JUP_MAX_REWARDS_RATE;
+  }
+  return {
+    rewardsRate,
+    rewardsEnded: false,
+    rewardsStartTime: rewardsModel.startTime
+  };
+}
+function calculateJupLendRewardsRateForExchangePrice(rewardsModel, totalAssets, currentTimestamp) {
+  const defaultResult = { rate: new BN2(0), rewardsStartTime: rewardsModel.startTime };
+  if (rewardsModel.startTime.isZero() || rewardsModel.duration.isZero()) {
+    return defaultResult;
+  }
+  if (currentTimestamp.gt(rewardsModel.startTime.add(rewardsModel.duration))) {
+    return defaultResult;
+  }
+  if (totalAssets.lt(rewardsModel.startTvl)) {
+    return defaultResult;
+  }
+  let rate = rewardsModel.yearlyReward.mul(JUP_EXCHANGE_PRICES_PRECISION).div(totalAssets);
+  if (rate.gt(JUP_MAX_REWARDS_RATE)) {
+    rate = JUP_MAX_REWARDS_RATE;
+  }
+  return { rate, rewardsStartTime: rewardsModel.startTime };
+}
+function calculateJupLendNewExchangePrice(lendingState, tokenReserve, rewardsModel, fTokenTotalSupply, currentTimestamp) {
+  const oldTokenExchangePrice = lendingState.tokenExchangePrice;
+  const oldLiquidityExchangePrice = lendingState.liquidityExchangePrice;
+  const currentLiquidityExchangePrice = tokenReserve.supplyExchangePrice;
+  let rewardsRate = new BN2(0);
+  let rewardsStartTime = lendingState.lastUpdateTimestamp;
+  if (rewardsModel) {
+    const totalAssets = calculateJupLendTotalAssets(lendingState, fTokenTotalSupply);
+    const result = calculateJupLendRewardsRateForExchangePrice(
+      rewardsModel,
+      totalAssets,
+      currentTimestamp
+    );
+    rewardsRate = result.rate;
+    rewardsStartTime = result.rewardsStartTime;
+  }
+  let lastUpdateTime = lendingState.lastUpdateTimestamp;
+  if (lastUpdateTime.lt(rewardsStartTime)) {
+    lastUpdateTime = rewardsStartTime;
+  }
+  const secondsElapsed = currentTimestamp.sub(lastUpdateTime);
+  let totalReturnPercent = rewardsRate.mul(secondsElapsed).div(JUP_SECONDS_PER_YEAR).mul(new BN2(100));
+  const delta = currentLiquidityExchangePrice.sub(oldLiquidityExchangePrice);
+  totalReturnPercent = totalReturnPercent.add(
+    delta.mul(new BN2(1e14)).div(oldLiquidityExchangePrice)
+  );
+  return oldTokenExchangePrice.add(oldTokenExchangePrice.mul(totalReturnPercent).div(new BN2(1e14)));
+}
+function calculateJupLendLiquiditySupplyRate(tokenReserve) {
+  const borrowRate = new BN2(tokenReserve.borrowRate);
+  const fee = new BN2(tokenReserve.feeOnInterest);
+  if (tokenReserve.totalSupplyWithInterest.isZero()) {
+    return new BN2(0);
+  }
+  const borrowWithInterestForRate = tokenReserve.totalBorrowWithInterest.mul(tokenReserve.borrowExchangePrice).div(JUP_EXCHANGE_PRICES_PRECISION);
+  const supplyWithInterestForRate = tokenReserve.totalSupplyWithInterest.mul(tokenReserve.supplyExchangePrice).div(JUP_EXCHANGE_PRICES_PRECISION);
+  if (supplyWithInterestForRate.isZero()) {
+    return new BN2(0);
+  }
+  return borrowRate.mul(new BN2(1e4).sub(fee)).mul(borrowWithInterestForRate).div(supplyWithInterestForRate.mul(new BN2(1e4)));
+}
+function calculateJupLendSupplyRate(lendingState, tokenReserve, rewardsModel, fTokenTotalSupply) {
+  const supplyRate = calculateJupLendLiquiditySupplyRate(tokenReserve);
+  let totalRateBps = supplyRate.toNumber();
+  if (rewardsModel) {
+    const totalAssets = calculateJupLendTotalAssets(lendingState, fTokenTotalSupply);
+    const currentTimestamp = new BN2(Math.floor(Date.now() / 1e3));
+    const { rewardsRate } = calculateJupLendRewardsRate(
+      rewardsModel,
+      totalAssets,
+      currentTimestamp
+    );
+    totalRateBps += rewardsRate.toNumber();
+  }
+  return totalRateBps / 1e4;
+}
+function calculateJupLendSupplyAPY(tokenReserve) {
+  const supplyRateBps = calculateJupLendLiquiditySupplyRate(tokenReserve);
+  const apr = supplyRateBps.toNumber() / 1e4;
+  return aprToApy2(apr);
+}
+function calculateJupLendBorrowRate(rateModel, utilizationBps) {
+  const u = Math.max(0, Math.min(1e4, utilizationBps));
+  if (rateModel.version === 2) {
+    if (u <= rateModel.kink1Utilization) {
+      return linearInterpolate(
+        0,
+        rateModel.rateAtZero,
+        rateModel.kink1Utilization,
+        rateModel.rateAtKink1,
+        u
+      );
+    } else if (u <= rateModel.kink2Utilization) {
+      return linearInterpolate(
+        rateModel.kink1Utilization,
+        rateModel.rateAtKink1,
+        rateModel.kink2Utilization,
+        rateModel.rateAtKink2,
+        u
+      );
+    } else {
+      return linearInterpolate(
+        rateModel.kink2Utilization,
+        rateModel.rateAtKink2,
+        1e4,
+        rateModel.rateAtMax,
+        u
+      );
+    }
+  } else {
+    if (u <= rateModel.kink1Utilization) {
+      return linearInterpolate(
+        0,
+        rateModel.rateAtZero,
+        rateModel.kink1Utilization,
+        rateModel.rateAtKink1,
+        u
+      );
+    } else {
+      return linearInterpolate(
+        rateModel.kink1Utilization,
+        rateModel.rateAtKink1,
+        1e4,
+        rateModel.rateAtMax,
+        u
+      );
+    }
+  }
+}
+function linearInterpolate(x0, y0, x1, y1, x) {
+  if (x1 === x0) return y0;
+  return y0 + (y1 - y0) * (x - x0) / (x1 - x0);
+}
+function generateJupLendSupplyCurve(rateModel, feeOnInterest) {
+  const feeMultiplier = 1 - feeOnInterest / 1e4;
+  return Array.from({ length: 101 }, (_, i) => {
+    const utilizationFraction = i / 100;
+    const utilizationBps = i * 100;
+    const borrowRateBps = calculateJupLendBorrowRate(rateModel, utilizationBps);
+    const borrowRateDecimal = borrowRateBps / 1e4;
+    const supplyAPR = borrowRateDecimal * feeMultiplier * utilizationFraction;
+    const supplyAPY = aprToApy2(supplyAPR);
+    return {
+      utilization: i,
+      // 0-100
+      supplyAPY: supplyAPY * 100
+      // Convert to percentage
+    };
+  });
+}
+function getJupLendRewards(lendingState, rewardsModel, fTokenTotalSupply) {
+  if (lendingState.rewardsRateModel.equals(PublicKey.default)) {
+    return {
+      rewardsRate: new BN2(0),
+      rewardsEnded: false,
+      rewardsStartTime: new BN2(0)
+    };
+  }
+  const totalAssets = calculateJupLendTotalAssets(lendingState, fTokenTotalSupply);
+  const currentTimestamp = new BN2(Math.floor(Date.now() / 1e3));
+  return calculateJupLendRewardsRate(rewardsModel, totalAssets, currentTimestamp);
+}
+var UPDATE_RATE_DISCRIMINATOR = Buffer.from([
+  24,
+  225,
+  53,
+  189,
+  72,
+  212,
+  225,
+  178
+]);
+var makeUpdateJupLendRateIx = (lending, mint, fTokenMint, supplyTokenReservesLiquidity, rewardsRateModel) => {
+  const keys = [
+    // lending: writable (exchange prices are updated)
+    { pubkey: lending, isSigner: false, isWritable: true },
+    // mint: read-only
+    { pubkey: mint, isSigner: false, isWritable: false },
+    // fTokenMint: read-only
+    { pubkey: fTokenMint, isSigner: false, isWritable: false },
+    // supplyTokenReservesLiquidity: read-only
+    { pubkey: supplyTokenReservesLiquidity, isSigner: false, isWritable: false },
+    // rewardsRateModel: read-only
+    { pubkey: rewardsRateModel, isSigner: false, isWritable: false }
+  ];
+  return new TransactionInstruction({
+    keys,
+    programId: JUP_LEND_PROGRAM_ID,
+    data: UPDATE_RATE_DISCRIMINATOR
+  });
+};
+
+// src/vendor/jup-lend/actions/update-rate.ts
+function makeUpdateJupLendRate({ lendingState }) {
+  return makeUpdateJupLendRateIx(
+    lendingState.pubkey,
+    lendingState.mint,
+    lendingState.fTokenMint,
+    lendingState.tokenReservesLiquidity,
+    lendingState.rewardsRateModel
+  );
+}
 
-export { ACCOUNT_SIZE, ACCOUNT_TYPE_SIZE, ASSOCIATED_TOKEN_PROGRAM_ID, AccountLayout, AccountState, AccountType, CorpAction, DEFAULT_RECENT_SLOT_DURATION_MS, DRIFT_IDL, DRIFT_PROGRAM_ID, DriftSpotBalanceType, ExtensionType, FARMS_PROGRAM_ID, KFARMS_IDL, KLEND_ACCOUNT_CODER, KLEND_IDL, KLEND_PROGRAM_ID, LENGTH_SIZE, MAX_SLOT_DIFFERENCE, MEMO_PROGRAM_ID, MINT_SIZE, MULTISIG_SIZE, MintLayout, MultisigLayout, NATIVE_MINT, ONE, ONE_HUNDRED_PCT_IN_BPS, ONE_YEAR, PERCENTAGE_PRECISION, PERCENTAGE_PRECISION_EXP, PriceStatus, PriceType, REFRESH_OBLIGATION_DISCRIMINATOR, SEED_BASE_REFERRER_STATE, SEED_BASE_REFERRER_TOKEN_STATE, SEED_BASE_SHORT_URL, SEED_BASE_USER_METADATA, SEED_DRIFT_SIGNER, SEED_DRIFT_STATE, SEED_FEE_RECEIVER, SEED_LENDING_MARKET_AUTH, SEED_RESERVE_COLL_MINT, SEED_RESERVE_COLL_SUPPLY, SEED_RESERVE_LIQ_SUPPLY, SEED_SPOT_MARKET, SEED_SPOT_MARKET_VAULT, SEED_USER, SEED_USER_STATE, SEED_USER_STATS, SLOTS_PER_DAY, SLOTS_PER_HOUR, SLOTS_PER_MINUTE, SLOTS_PER_SECOND, SLOTS_PER_YEAR, SPOT_MARKET_RATE_PRECISION, SPOT_MARKET_RATE_PRECISION_EXP, SPOT_MARKET_UTILIZATION_PRECISION, SPOT_MARKET_UTILIZATION_PRECISION_EXP, SWITCHBOARD_ONDEMANDE_PRICE_PRECISION, SinglePoolInstruction, SplAccountType, SpotBalanceType, TEN, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, TYPE_SIZE, TokenAccountNotFoundError, TokenError, TokenInstruction, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidInstructionDataError, TokenInvalidInstructionKeysError, TokenInvalidInstructionProgramError, TokenInvalidInstructionTypeError, TokenInvalidMintError, TokenInvalidOwnerError, TokenOwnerOffCurveError, TokenUnsupportedInstructionError, ZERO, addSigners, calculateAPYFromAPR, calculateDriftBorrowAPR, calculateDriftBorrowAPY, calculateDriftBorrowRate, calculateDriftDepositRate, calculateDriftInterestRate, calculateDriftLendingAPR, calculateDriftLendingAPY, calculateDriftUtilization, calculateKaminoEstimatedBorrowRate, calculateKaminoEstimatedSupplyRate, calculateKaminoSupplyAPY, calculateRewardApy, calculateSlotAdjustmentFactor, calculateUtilizationRatio, closeAccountInstructionData, createAccountIx, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createInitializeAccountInstruction, createMemoInstruction, createPoolOnrampIx, createSyncNativeInstruction, createTransferCheckedInstruction, decodeDriftSpotMarketData, decodeDriftStateData, decodeDriftUserData, decodeDriftUserStatsData, decodeFarmDataRaw, decodeKlendObligationData, decodeKlendReserveData, decodeSwitchboardPullFeedData, deriveBaseObligation, deriveDriftSigner, deriveDriftSpotMarket, deriveDriftSpotMarketVault, deriveDriftState, deriveDriftUser, deriveDriftUserStats, deriveFeeReceiver, deriveLendingMarketAuthority, deriveObligation, deriveReferrerState, deriveReferrerTokenState, deriveReserveCollateralMint, deriveReserveCollateralSupply, deriveReserveLiquiditySupply, deriveShortUrl, deriveUserMetadata, deriveUserState, driftRewardsRawToDto, driftSpotMarketRawToDto, driftStateRawToDto, driftUserRawToDto, driftUserStatsRawToDto, dtoToDriftRewardsRaw, dtoToDriftSpotMarketRaw, dtoToDriftStateRaw, dtoToDriftUserRaw, dtoToDriftUserStatsRaw, dtoToFarmRaw, dtoToObligationRaw, dtoToReserveRaw, farmRawToDto, findMplMetadataAddress, findPoolAddress, findPoolMintAddress, findPoolMintAddressByVoteAccount, findPoolMintAuthorityAddress, findPoolMplAuthorityAddress, findPoolOnRampAddress, findPoolStakeAddress, findPoolStakeAuthorityAddress, generateDriftReserveCurve, generateKaminoReserveCurve, getAccount, getAccountLen, getAllDerivedDriftAccounts, getAllDerivedKaminoAccounts, getAllRequiredMarkets, getAssociatedTokenAddressSync, getDriftRewards, getDriftTokenAmount, getFixedHostInterestRate, getKaminoBorrowRate, getKaminoTotalSupply, getMinimumBalanceForRentExemptAccount, getMinimumBalanceForRentExemptAccountWithExtensions, getMint, getMultipleAccounts, getProtocolTakeRatePct, getReserveRewardsApy, getRewardPerTimeUnitSecond, getStakeAccount, getSwitchboardProgram, initializeAccountInstructionData, initializeStakedPoolIxs, initializeStakedPoolTx, interpolateLinear, isSpotBalanceTypeVariant, layout, makeRefreshObligationIx, makeRefreshReservesBatchIx, makeRefreshingIxs, makeUpdateSpotMarketCumulativeInterestIx, makeUpdateSpotMarketIx, obligationRawToDto, parsePriceData, parsePriceInfo2 as parsePriceInfo, replenishPoolIx, reserveRawToDto, scaledSupplies, slotAdjustmentFactor, switchboardAccountCoder, syncNativeInstructionData, transferCheckedInstructionData, truncateBorrowCurve, unpackAccount };
+export { ACCOUNT_SIZE, ACCOUNT_TYPE_SIZE, ASSOCIATED_TOKEN_PROGRAM_ID, AccountLayout, AccountState, AccountType, CorpAction, DEFAULT_RECENT_SLOT_DURATION_MS, DRIFT_IDL, DRIFT_PROGRAM_ID, DriftSpotBalanceType, ExtensionType, FARMS_PROGRAM_ID, JUP_EXCHANGE_PRICES_PRECISION, JUP_LEND_IDL, JUP_LEND_PROGRAM_ID, JUP_LIQUIDITY_PROGRAM_ID, JUP_MAX_REWARDS_RATE, JUP_REWARDS_PROGRAM_ID, JUP_SECONDS_PER_YEAR, KFARMS_IDL, KLEND_ACCOUNT_CODER, KLEND_IDL, KLEND_PROGRAM_ID, LENGTH_SIZE, MAX_SLOT_DIFFERENCE, MEMO_PROGRAM_ID, MINT_SIZE, MULTISIG_SIZE, MintLayout, MultisigLayout, NATIVE_MINT, ONE, ONE_HUNDRED_PCT_IN_BPS, ONE_YEAR, PERCENTAGE_PRECISION, PERCENTAGE_PRECISION_EXP, PriceStatus, PriceType, REFRESH_OBLIGATION_DISCRIMINATOR, SEED_BASE_REFERRER_STATE, SEED_BASE_REFERRER_TOKEN_STATE, SEED_BASE_SHORT_URL, SEED_BASE_USER_METADATA, SEED_DRIFT_SIGNER, SEED_DRIFT_STATE, SEED_FEE_RECEIVER, SEED_F_TOKEN_MINT, SEED_LENDING, SEED_LENDING_ADMIN, SEED_LENDING_MARKET_AUTH, SEED_LENDING_REWARDS_RATE_MODEL, SEED_LIQUIDITY, SEED_RATE_MODEL, SEED_RESERVE, SEED_RESERVE_COLL_MINT, SEED_RESERVE_COLL_SUPPLY, SEED_RESERVE_LIQ_SUPPLY, SEED_SPOT_MARKET, SEED_SPOT_MARKET_VAULT, SEED_USER, SEED_USER_CLAIM, SEED_USER_STATE, SEED_USER_STATS, SEED_USER_SUPPLY_POSITION, SLOTS_PER_DAY, SLOTS_PER_HOUR, SLOTS_PER_MINUTE, SLOTS_PER_SECOND, SLOTS_PER_YEAR, SPOT_MARKET_RATE_PRECISION, SPOT_MARKET_RATE_PRECISION_EXP, SPOT_MARKET_UTILIZATION_PRECISION, SPOT_MARKET_UTILIZATION_PRECISION_EXP, SWITCHBOARD_ONDEMANDE_PRICE_PRECISION, SinglePoolInstruction, SplAccountType, SpotBalanceType, TEN, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, TYPE_SIZE, TokenAccountNotFoundError, TokenError, TokenInstruction, TokenInvalidAccountError, TokenInvalidAccountOwnerError, TokenInvalidAccountSizeError, TokenInvalidInstructionDataError, TokenInvalidInstructionKeysError, TokenInvalidInstructionProgramError, TokenInvalidInstructionTypeError, TokenInvalidMintError, TokenInvalidOwnerError, TokenOwnerOffCurveError, TokenUnsupportedInstructionError, ZERO, addSigners, calculateAPYFromAPR, calculateDriftBorrowAPR, calculateDriftBorrowAPY, calculateDriftBorrowRate, calculateDriftDepositRate, calculateDriftInterestRate, calculateDriftLendingAPR, calculateDriftLendingAPY, calculateDriftUtilization, calculateJupLendBorrowRate, calculateJupLendLiquiditySupplyRate, calculateJupLendNewExchangePrice, calculateJupLendRewardsRate, calculateJupLendRewardsRateForExchangePrice, calculateJupLendSupplyAPY, calculateJupLendSupplyRate, calculateJupLendTotalAssets, calculateKaminoEstimatedBorrowRate, calculateKaminoEstimatedSupplyRate, calculateKaminoSupplyAPY, calculateRewardApy, calculateSlotAdjustmentFactor, calculateUtilizationRatio, closeAccountInstructionData, createAccountIx, createAssociatedTokenAccountIdempotentInstruction, createAssociatedTokenAccountInstruction, createCloseAccountInstruction, createInitializeAccountInstruction, createMemoInstruction, createPoolOnrampIx, createSyncNativeInstruction, createTransferCheckedInstruction, decodeDriftSpotMarketData, decodeDriftStateData, decodeDriftUserData, decodeDriftUserStatsData, decodeFarmDataRaw, decodeJupLendingRewardsRateModelData, decodeJupLendingStateData, decodeJupRateModelData, decodeJupTokenReserveData, decodeKlendObligationData, decodeKlendReserveData, decodeSwitchboardPullFeedData, deriveBaseObligation, deriveDriftSigner, deriveDriftSpotMarket, deriveDriftSpotMarketVault, deriveDriftState, deriveDriftUser, deriveDriftUserStats, deriveFeeReceiver, deriveJupLendClaimAccount, deriveJupLendFTokenMint, deriveJupLendLending, deriveJupLendLendingAdmin, deriveJupLendLendingPdas, deriveJupLendLendingRewardsRateModel, deriveJupLendLiquidity, deriveJupLendLiquiditySupplyPositionPda, deriveJupLendLiquidityVaultAta, deriveJupLendRateModel, deriveJupLendTokenReserve, deriveLendingMarketAuthority, deriveObligation, deriveReferrerState, deriveReferrerTokenState, deriveReserveCollateralMint, deriveReserveCollateralSupply, deriveReserveLiquiditySupply, deriveShortUrl, deriveUserMetadata, deriveUserState, driftRewardsRawToDto, driftSpotMarketRawToDto, driftStateRawToDto, driftUserRawToDto, driftUserStatsRawToDto, dtoToDriftRewardsRaw, dtoToDriftSpotMarketRaw, dtoToDriftStateRaw, dtoToDriftUserRaw, dtoToDriftUserStatsRaw, dtoToFarmRaw, dtoToJupLendingRewardsRateModelRaw, dtoToJupLendingStateRaw, dtoToJupRateModelRaw, dtoToJupTokenReserveRaw, dtoToObligationRaw, dtoToReserveRaw, farmRawToDto, findMplMetadataAddress, findPoolAddress, findPoolMintAddress, findPoolMintAddressByVoteAccount, findPoolMintAuthorityAddress, findPoolMplAuthorityAddress, findPoolOnRampAddress, findPoolStakeAddress, findPoolStakeAuthorityAddress, generateDriftReserveCurve, generateJupLendSupplyCurve, generateKaminoReserveCurve, getAccount, getAccountLen, getAllDerivedDriftAccounts, getAllDerivedJupLendAccounts, getAllDerivedKaminoAccounts, getAllRequiredMarkets, getAssociatedTokenAddressSync, getDriftRewards, getDriftTokenAmount, getFixedHostInterestRate, getJupLendRewards, getKaminoBorrowRate, getKaminoTotalSupply, getMinimumBalanceForRentExemptAccount, getMinimumBalanceForRentExemptAccountWithExtensions, getMint, getMultipleAccounts, getProtocolTakeRatePct, getReserveRewardsApy, getRewardPerTimeUnitSecond, getStakeAccount, getSwitchboardProgram, initializeAccountInstructionData, initializeStakedPoolIxs, initializeStakedPoolTx, interpolateLinear, isSpotBalanceTypeVariant, jupLendingRewardsRateModelRawToDto, jupLendingStateRawToDto, jupRateModelRawToDto, jupTokenReserveRawToDto, layout, makeRefreshObligationIx, makeRefreshReservesBatchIx, makeRefreshingIxs, makeUpdateJupLendRate, makeUpdateJupLendRateIx, makeUpdateSpotMarketCumulativeInterestIx, makeUpdateSpotMarketIx, obligationRawToDto, parsePriceData, parsePriceInfo2 as parsePriceInfo, replenishPoolIx, reserveRawToDto, scaledSupplies, slotAdjustmentFactor, switchboardAccountCoder, syncNativeInstructionData, transferCheckedInstructionData, truncateBorrowCurve, unpackAccount };
 //# sourceMappingURL=vendor.js.map
 //# sourceMappingURL=vendor.js.map