@kamino-finance/klend-sdk 5.0.3 → 5.0.5

package/src/classes/vault.ts

@@ -23,6 +23,8 @@ import {
   WRAPPED_SOL_MINT,
 } from '../lib';
 import {
+  // closeVault,
+  // CloseVaultAccounts,
   DepositAccounts,
   DepositArgs,
   initVault,
@@ -44,6 +46,8 @@ import { PROGRAM_ID } from '../idl_codegen/programId';
 import { DEFAULT_RECENT_SLOT_DURATION_MS, ReserveWithAddress } from './reserve';
 import { Fraction } from './fraction';
 import { lendingMarketAuthPda } from '../utils/seeds';
+import bs58 from 'bs58';
+import { getProgramAccounts } from '../utils/rpc';
 
 export const kaminoVaultId = new PublicKey('kvauTFR8qm1dhniz6pYuBZkuene3Hfrs1VQhVRgCNrr');
 
@@ -124,6 +128,7 @@ export class KaminoVaultClient {
       systemProgram: SystemProgram.programId,
       rent: SYSVAR_RENT_PUBKEY,
       tokenProgram: vaultConfig.tokenMintProgramId,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
     const initVaultIx = initVault(initVaultAccounts, this._kaminoVaultProgramId);
 
@@ -145,7 +150,11 @@ export class KaminoVaultClient {
     const vaultState: VaultState = await vault.getState(this.getConnection());
     const reserveState: Reserve = reserveAllocationConfig.getReserveState();
 
-    const cTokenVault = getCTokenVaultPda(reserveAllocationConfig.getReserveAddress(), this._kaminoVaultProgramId);
+    const cTokenVault = getCTokenVaultPda(
+      vault.address,
+      reserveAllocationConfig.getReserveAddress(),
+      this._kaminoVaultProgramId
+    );
 
     const updateReserveAllocationAccounts: UpdateReserveAllocationAccounts = {
       adminAuthority: vaultState.adminAuthority,
@@ -171,6 +180,17 @@ export class KaminoVaultClient {
     );
   }
 
+  // async closeVaultIx(vault: KaminoVault): Promise<TransactionInstruction> {
+  //   const vaultState: VaultState = await vault.getState(this.getConnection());
+
+  //   const closeVaultAccounts: CloseVaultAccounts = {
+  //     adminAuthority: vaultState.adminAuthority,
+  //     vaultState: vault.address,
+  //   };
+
+  //   return closeVault(closeVaultAccounts, this._kaminoVaultProgramId);
+  // }
+
   /**
    * This function creates instructions to deposit into a vault. It will also create ATA creation instructions for the vault shares that the user receives in return
    * @param user - user to deposit
@@ -225,6 +245,8 @@ export class KaminoVaultClient {
       userSharesAta: userSharesAta,
       tokenProgram: TOKEN_PROGRAM_ID,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+      klendProgram: this._kaminoLendProgramId,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const depositArgs: DepositArgs = {
@@ -235,10 +257,24 @@ export class KaminoVaultClient {
 
     const vaultReserves = this.getVaultReserves(vaultState);
 
-    const vaultReservesAccountMetas: AccountMeta[] = vaultReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: false };
+    const vaultReservesState = await this.loadVaultReserves(vaultState);
+
+    let vaultReservesAccountMetas: AccountMeta[] = [];
+    let vaultReservesLendingMarkets: AccountMeta[] = [];
+    vaultReserves.forEach((reserve) => {
+      const reserveState = vaultReservesState.get(reserve);
+      if (reserveState === undefined) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
+      }
+      vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+        { pubkey: reserve, isSigner: false, isWritable: true },
+      ]);
+      vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+        { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+      ]);
     });
     depositIx.keys = depositIx.keys.concat(vaultReservesAccountMetas);
+    depositIx.keys = depositIx.keys.concat(vaultReservesLendingMarkets);
 
     return [...createAtasIxns, depositIx, ...closeAtasIxns];
   }
@@ -341,7 +377,7 @@ export class KaminoVaultClient {
    * @param kaminoVault - vault to invest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investAllReservesIxs(vault: KaminoVault): Promise<TransactionInstruction[]> {
+  async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
     //TODO: Order invest ixns by - invest that removes first, then invest that adds
 
     const vaultState = await vault.getState(this._connection);
@@ -352,7 +388,7 @@ export class KaminoVaultClient {
       if (reserveState === null) {
         throw new Error(`Reserve ${reserve.toBase58()} not found`);
       }
-      investIxns.push(await this.investSingleReserveIxs(vault, { address: reserve, state: reserveState }));
+      investIxns.push(await this.investSingleReserveIxs(payer, vault, { address: reserve, state: reserveState }));
     }
 
     return investIxns;
@@ -364,14 +400,21 @@ export class KaminoVaultClient {
    * @param reserve - reserve to invest into or disinvest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investSingleReserveIxs(vault: KaminoVault, reserve: ReserveWithAddress): Promise<TransactionInstruction> {
+  async investSingleReserveIxs(
+    payer: PublicKey,
+    vault: KaminoVault,
+    reserve: ReserveWithAddress
+  ): Promise<TransactionInstruction> {
     const vaultState = await vault.getState(this._connection);
 
-    const cTokenVault = getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId);
+    const cTokenVault = getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId);
     const lendingMarketAuth = lendingMarketAuthPda(reserve.state.lendingMarket, this._kaminoLendProgramId)[0];
 
+    // todo: create ata if needed here
+    const payerTokenAta = getAssociatedTokenAddress(vaultState.tokenMint, payer);
+
     const investAccounts: InvestAccounts = {
-      adminAuthority: vaultState.adminAuthority,
+      payer,
       vaultState: vault.address,
       tokenVault: vaultState.tokenVault,
       baseVaultAuthority: vaultState.baseVaultAuthority,
@@ -385,6 +428,10 @@ export class KaminoVaultClient {
       klendProgram: this._kaminoLendProgramId,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       tokenProgram: TOKEN_PROGRAM_ID,
+      payerTokenAccount: payerTokenAta,
+      tokenMint: vaultState.tokenMint,
+      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const investIx = invest(investAccounts, this._kaminoVaultProgramId);
@@ -398,7 +445,7 @@ export class KaminoVaultClient {
     return investIx;
   }
 
-  private withdrawIxn(
+  private async withdrawIxn(
     user: PublicKey,
     vault: KaminoVault,
     vaultState: VaultState,
@@ -407,7 +454,7 @@ export class KaminoVaultClient {
     userSharesAta: PublicKey,
     userTokenAta: PublicKey,
     shareAmountLamports: Decimal
-  ): TransactionInstruction {
+  ): Promise<TransactionInstruction> {
     const lendingMarketAuth = lendingMarketAuthPda(marketWithAddress.address, this._kaminoLendProgramId)[0];
 
     const withdrawAccounts: WithdrawAccounts = {
@@ -422,13 +469,15 @@ export class KaminoVaultClient {
       tokenProgram: TOKEN_PROGRAM_ID,
       instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       reserve: reserve.address,
-      ctokenVault: getCTokenVaultPda(reserve.address, this._kaminoVaultProgramId),
+      ctokenVault: getCTokenVaultPda(vault.address, reserve.address, this._kaminoVaultProgramId),
       /** CPI accounts */
       lendingMarket: marketWithAddress.address,
       lendingMarketAuthority: lendingMarketAuth,
       reserveLiquiditySupply: reserve.state.liquidity.supplyVault,
       reserveCollateralMint: reserve.state.collateral.mintPubkey,
       klendProgram: this._kaminoLendProgramId,
+      reserveCollateralTokenProgram: TOKEN_PROGRAM_ID,
+      sharesTokenProgram: TOKEN_PROGRAM_ID,
     };
 
     const withdrawArgs: WithdrawArgs = {
@@ -438,10 +487,26 @@ export class KaminoVaultClient {
     const withdrawIxn = withdraw(withdrawArgs, withdrawAccounts, this._kaminoVaultProgramId);
 
     const vaultReserves = this.getVaultReserves(vaultState);
-    const vaultReservesAccountMetas: AccountMeta[] = vaultReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: false };
+    const vaultReservesState = await this.loadVaultReserves(vaultState);
+
+    let vaultReservesAccountMetas: AccountMeta[] = [];
+    let vaultReservesLendingMarkets: AccountMeta[] = [];
+
+    vaultReserves.forEach((reserve) => {
+      const reserveState = vaultReservesState.get(reserve);
+      if (reserveState === undefined) {
+        throw new Error(`Reserve ${reserve.toBase58()} not found`);
+      }
+
+      vaultReservesAccountMetas = vaultReservesAccountMetas.concat([
+        { pubkey: reserve, isSigner: false, isWritable: true },
+      ]);
+      vaultReservesLendingMarkets = vaultReservesLendingMarkets.concat([
+        { pubkey: reserveState.state.lendingMarket, isSigner: false, isWritable: false },
+      ]);
     });
     withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesAccountMetas);
+    withdrawIxn.keys = withdrawIxn.keys.concat(vaultReservesLendingMarkets);
 
     return withdrawIxn;
   }
@@ -590,6 +655,44 @@ export class KaminoVaultClient {
     return vaultTokensPerShare;
   }
 
+  /**
+   * Get all vaults
+   * @returns an array of all vaults
+   */
+  async getAllVaults(): Promise<KaminoVault[]> {
+    const filters = [
+      {
+        dataSize: VaultState.layout.span + 8,
+      },
+      {
+        memcmp: {
+          offset: 0,
+          bytes: bs58.encode(VaultState.discriminator),
+        },
+      },
+    ];
+
+    const [kaminoVaults] = await Promise.all([
+      getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
+        commitment: this._connection.commitment ?? 'processed',
+        filters,
+      }),
+    ]);
+
+    return kaminoVaults.map((kaminoVault) => {
+      if (kaminoVault.account === null) {
+        throw new Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} does not exist`);
+      }
+
+      const kaminoVaultAccount = VaultState.decode(kaminoVault.account.data);
+      if (!kaminoVaultAccount) {
+        throw Error(`kaminoVault with pubkey ${kaminoVault.pubkey.toString()} could not be decoded`);
+      }
+
+      return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
+    });
+  }
+
   /**
    * This will return an unsorted hash map of all reserves that the given vault has allocations for, toghether with the amount that can be withdrawn from each of the reserves
    * @param vault - the kamino vault to get available liquidity to withdraw for
@@ -673,40 +776,6 @@ export class KaminoVaultClient {
 
     return kaminoReserves;
   }
-
-  /**
-   * Get all vaults
-   * @returns an array of all vaults
-   */
-  async getAllVaults(): Promise<KaminoVault[]> {
-    const { getProgramAccounts } = await import('../utils/rpc');
-    const filters = [
-      {
-        dataSize: VaultState.layout.span + 8,
-      },
-    ];
-
-    const [, kaminoVaults] = await Promise.all([
-      this._connection.getSlot(),
-      getProgramAccounts(this._connection, this._kaminoVaultProgramId, {
-        commitment: this._connection.commitment ?? 'processed',
-        filters,
-      }),
-    ]);
-
-    return kaminoVaults.map((kaminoVault) => {
-      if (kaminoVault.account === null) {
-        throw new Error('Invalid account');
-      }
-
-      const kaminoVaultAccount = VaultState.decode(kaminoVault.account.data);
-      if (!kaminoVaultAccount) {
-        throw Error('Could not parse obligation.');
-      }
-
-      return new KaminoVault(kaminoVault.pubkey, kaminoVaultAccount, this._kaminoVaultProgramId);
-    });
-  }
 } // KaminoVaultClient
 
 export class KaminoVault {
@@ -804,9 +873,14 @@ export class ReserveAllocationConfig {
   }
 }
 
-export function getCTokenVaultPda(reserveAddress: PublicKey, kaminoVaultProgramId: PublicKey) {
+export function getCTokenVaultPda(vaultAddress: PublicKey, reserveAddress: PublicKey, kaminoVaultProgramId: PublicKey) {
   return PublicKey.findProgramAddressSync(
-    [Buffer.from(CTOKEN_VAULT_SEED), reserveAddress.toBytes()],
+    [Buffer.from(CTOKEN_VAULT_SEED), vaultAddress.toBytes(), reserveAddress.toBytes()],
     kaminoVaultProgramId
   )[0];
 }
+
+export type VaultHolder = {
+  holderPubkey: PublicKey;
+  amount: Decimal;
+};

package/src/client_kamino_manager.ts

@@ -296,6 +296,24 @@ async function main() {
       mode === 'execute' && console.log('Vault allocation updated:', updateVaultAllocationSig);
     });
 
+  // commands
+  //   .command('close-vault')
+  //   .requiredOption('--vault <string>', 'Vault address')
+  //   .option(`--staging`, 'If true, will use the staging programs')
+  //   .action(async ({vault, staging}) => {
+  //     console.log("silviuuuu vault", vault);
+  //     const env = initializeClient(false, staging);
+  //     const vaultAddress = new PublicKey(vault);
+
+  //     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
+
+  //     const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
+  //     const instructions = await kaminoManager.closeVault(kaminoVault);
+
+  //     const closeVaultSig = await processTxn(env.client, env.payer, [instructions], 'execute', 2500, []);
+  //     console.log('Vault closed:', closeVaultSig);
+  //   });
+
   commands.command('get-oracle-mappings').action(async () => {
     const env = initializeClient(false, false);
     const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);

package/src/idl_codegen_kamino_vault/accounts/Reserve.ts

@@ -1,136 +1,148 @@
-import { PublicKey, Connection } from '@solana/web3.js';
-import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
-import { PROGRAM_ID } from '../programId';
+import { PublicKey, Connection } from "@solana/web3.js"
+import BN from "bn.js" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from "@coral-xyz/borsh" // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from "../types" // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from "../programId"
 
 export interface ReserveFields {
   /** Version of the reserve */
-  version: BN;
+  version: BN
   /** Last slot when supply and rates updated */
-  lastUpdate: types.LastUpdateFields;
+  lastUpdate: types.LastUpdateFields
   /** Lending market address */
-  lendingMarket: PublicKey;
-  farmCollateral: PublicKey;
-  farmDebt: PublicKey;
+  lendingMarket: PublicKey
+  farmCollateral: PublicKey
+  farmDebt: PublicKey
   /** Reserve liquidity */
-  liquidity: types.ReserveLiquidityFields;
-  reserveLiquidityPadding: Array<BN>;
+  liquidity: types.ReserveLiquidityFields
+  reserveLiquidityPadding: Array<BN>
   /** Reserve collateral */
-  collateral: types.ReserveCollateralFields;
-  reserveCollateralPadding: Array<BN>;
+  collateral: types.ReserveCollateralFields
+  reserveCollateralPadding: Array<BN>
   /** Reserve configuration values */
-  config: types.ReserveConfigFields;
-  configPadding: Array<BN>;
-  borrowedAmountOutsideElevationGroup: BN;
+  config: types.ReserveConfigFields
+  configPadding: Array<BN>
+  borrowedAmountOutsideElevationGroup: BN
   /**
    * Amount of token borrowed in lamport of debt asset in the given
    * elevation group when this reserve is part of the collaterals.
    */
-  borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>;
-  padding: Array<BN>;
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  padding: Array<BN>
 }
 
 export interface ReserveJSON {
   /** Version of the reserve */
-  version: string;
+  version: string
   /** Last slot when supply and rates updated */
-  lastUpdate: types.LastUpdateJSON;
+  lastUpdate: types.LastUpdateJSON
   /** Lending market address */
-  lendingMarket: string;
-  farmCollateral: string;
-  farmDebt: string;
+  lendingMarket: string
+  farmCollateral: string
+  farmDebt: string
   /** Reserve liquidity */
-  liquidity: types.ReserveLiquidityJSON;
-  reserveLiquidityPadding: Array<string>;
+  liquidity: types.ReserveLiquidityJSON
+  reserveLiquidityPadding: Array<string>
   /** Reserve collateral */
-  collateral: types.ReserveCollateralJSON;
-  reserveCollateralPadding: Array<string>;
+  collateral: types.ReserveCollateralJSON
+  reserveCollateralPadding: Array<string>
   /** Reserve configuration values */
-  config: types.ReserveConfigJSON;
-  configPadding: Array<string>;
-  borrowedAmountOutsideElevationGroup: string;
+  config: types.ReserveConfigJSON
+  configPadding: Array<string>
+  borrowedAmountOutsideElevationGroup: string
   /**
    * Amount of token borrowed in lamport of debt asset in the given
    * elevation group when this reserve is part of the collaterals.
    */
-  borrowedAmountsAgainstThisReserveInElevationGroups: Array<string>;
-  padding: Array<string>;
+  borrowedAmountsAgainstThisReserveInElevationGroups: Array<string>
+  padding: Array<string>
 }
 
 export class Reserve {
   /** Version of the reserve */
-  readonly version: BN;
+  readonly version: BN
   /** Last slot when supply and rates updated */
-  readonly lastUpdate: types.LastUpdate;
+  readonly lastUpdate: types.LastUpdate
   /** Lending market address */
-  readonly lendingMarket: PublicKey;
-  readonly farmCollateral: PublicKey;
-  readonly farmDebt: PublicKey;
+  readonly lendingMarket: PublicKey
+  readonly farmCollateral: PublicKey
+  readonly farmDebt: PublicKey
   /** Reserve liquidity */
-  readonly liquidity: types.ReserveLiquidity;
-  readonly reserveLiquidityPadding: Array<BN>;
+  readonly liquidity: types.ReserveLiquidity
+  readonly reserveLiquidityPadding: Array<BN>
   /** Reserve collateral */
-  readonly collateral: types.ReserveCollateral;
-  readonly reserveCollateralPadding: Array<BN>;
+  readonly collateral: types.ReserveCollateral
+  readonly reserveCollateralPadding: Array<BN>
   /** Reserve configuration values */
-  readonly config: types.ReserveConfig;
-  readonly configPadding: Array<BN>;
-  readonly borrowedAmountOutsideElevationGroup: BN;
+  readonly config: types.ReserveConfig
+  readonly configPadding: Array<BN>
+  readonly borrowedAmountOutsideElevationGroup: BN
   /**
    * Amount of token borrowed in lamport of debt asset in the given
    * elevation group when this reserve is part of the collaterals.
    */
-  readonly borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>;
-  readonly padding: Array<BN>;
+  readonly borrowedAmountsAgainstThisReserveInElevationGroups: Array<BN>
+  readonly padding: Array<BN>
 
-  static readonly discriminator = Buffer.from([43, 242, 204, 202, 26, 247, 59, 127]);
+  static readonly discriminator = Buffer.from([
+    43, 242, 204, 202, 26, 247, 59, 127,
+  ])
 
   static readonly layout = borsh.struct([
-    borsh.u64('version'),
-    types.LastUpdate.layout('lastUpdate'),
-    borsh.publicKey('lendingMarket'),
-    borsh.publicKey('farmCollateral'),
-    borsh.publicKey('farmDebt'),
-    types.ReserveLiquidity.layout('liquidity'),
-    borsh.array(borsh.u64(), 150, 'reserveLiquidityPadding'),
-    types.ReserveCollateral.layout('collateral'),
-    borsh.array(borsh.u64(), 150, 'reserveCollateralPadding'),
-    types.ReserveConfig.layout('config'),
-    borsh.array(borsh.u64(), 117, 'configPadding'),
-    borsh.u64('borrowedAmountOutsideElevationGroup'),
-    borsh.array(borsh.u64(), 32, 'borrowedAmountsAgainstThisReserveInElevationGroups'),
-    borsh.array(borsh.u64(), 207, 'padding'),
-  ]);
+    borsh.u64("version"),
+    types.LastUpdate.layout("lastUpdate"),
+    borsh.publicKey("lendingMarket"),
+    borsh.publicKey("farmCollateral"),
+    borsh.publicKey("farmDebt"),
+    types.ReserveLiquidity.layout("liquidity"),
+    borsh.array(borsh.u64(), 150, "reserveLiquidityPadding"),
+    types.ReserveCollateral.layout("collateral"),
+    borsh.array(borsh.u64(), 150, "reserveCollateralPadding"),
+    types.ReserveConfig.layout("config"),
+    borsh.array(borsh.u64(), 117, "configPadding"),
+    borsh.u64("borrowedAmountOutsideElevationGroup"),
+    borsh.array(
+      borsh.u64(),
+      32,
+      "borrowedAmountsAgainstThisReserveInElevationGroups"
+    ),
+    borsh.array(borsh.u64(), 207, "padding"),
+  ])
 
   constructor(fields: ReserveFields) {
-    this.version = fields.version;
-    this.lastUpdate = new types.LastUpdate({ ...fields.lastUpdate });
-    this.lendingMarket = fields.lendingMarket;
-    this.farmCollateral = fields.farmCollateral;
-    this.farmDebt = fields.farmDebt;
-    this.liquidity = new types.ReserveLiquidity({ ...fields.liquidity });
-    this.reserveLiquidityPadding = fields.reserveLiquidityPadding;
-    this.collateral = new types.ReserveCollateral({ ...fields.collateral });
-    this.reserveCollateralPadding = fields.reserveCollateralPadding;
-    this.config = new types.ReserveConfig({ ...fields.config });
-    this.configPadding = fields.configPadding;
-    this.borrowedAmountOutsideElevationGroup = fields.borrowedAmountOutsideElevationGroup;
-    this.borrowedAmountsAgainstThisReserveInElevationGroups = fields.borrowedAmountsAgainstThisReserveInElevationGroups;
-    this.padding = fields.padding;
+    this.version = fields.version
+    this.lastUpdate = new types.LastUpdate({ ...fields.lastUpdate })
+    this.lendingMarket = fields.lendingMarket
+    this.farmCollateral = fields.farmCollateral
+    this.farmDebt = fields.farmDebt
+    this.liquidity = new types.ReserveLiquidity({ ...fields.liquidity })
+    this.reserveLiquidityPadding = fields.reserveLiquidityPadding
+    this.collateral = new types.ReserveCollateral({ ...fields.collateral })
+    this.reserveCollateralPadding = fields.reserveCollateralPadding
+    this.config = new types.ReserveConfig({ ...fields.config })
+    this.configPadding = fields.configPadding
+    this.borrowedAmountOutsideElevationGroup =
+      fields.borrowedAmountOutsideElevationGroup
+    this.borrowedAmountsAgainstThisReserveInElevationGroups =
+      fields.borrowedAmountsAgainstThisReserveInElevationGroups
+    this.padding = fields.padding
   }
 
-  static async fetch(c: Connection, address: PublicKey, programId: PublicKey = PROGRAM_ID): Promise<Reserve | null> {
-    const info = await c.getAccountInfo(address);
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Reserve | null> {
+    const info = await c.getAccountInfo(address)
 
     if (info === null) {
-      return null;
+      return null
     }
     if (!info.owner.equals(programId)) {
-      throw new Error("account doesn't belong to this program");
+      throw new Error("account doesn't belong to this program")
     }
 
-    return this.decode(info.data);
+    return this.decode(info.data)
   }
 
   static async fetchMultiple(
@@ -138,26 +150,26 @@ export class Reserve {
     addresses: PublicKey[],
     programId: PublicKey = PROGRAM_ID
   ): Promise<Array<Reserve | null>> {
-    const infos = await c.getMultipleAccountsInfo(addresses);
+    const infos = await c.getMultipleAccountsInfo(addresses)
 
     return infos.map((info) => {
       if (info === null) {
-        return null;
+        return null
       }
       if (!info.owner.equals(programId)) {
-        throw new Error("account doesn't belong to this program");
+        throw new Error("account doesn't belong to this program")
       }
 
-      return this.decode(info.data);
-    });
+      return this.decode(info.data)
+    })
   }
 
   static decode(data: Buffer): Reserve {
     if (!data.slice(0, 8).equals(Reserve.discriminator)) {
-      throw new Error('invalid account discriminator');
+      throw new Error("invalid account discriminator")
     }
 
-    const dec = Reserve.layout.decode(data.slice(8));
+    const dec = Reserve.layout.decode(data.slice(8))
 
     return new Reserve({
       version: dec.version,
@@ -171,10 +183,12 @@ export class Reserve {
       reserveCollateralPadding: dec.reserveCollateralPadding,
       config: types.ReserveConfig.fromDecoded(dec.config),
       configPadding: dec.configPadding,
-      borrowedAmountOutsideElevationGroup: dec.borrowedAmountOutsideElevationGroup,
-      borrowedAmountsAgainstThisReserveInElevationGroups: dec.borrowedAmountsAgainstThisReserveInElevationGroups,
+      borrowedAmountOutsideElevationGroup:
+        dec.borrowedAmountOutsideElevationGroup,
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        dec.borrowedAmountsAgainstThisReserveInElevationGroups,
       padding: dec.padding,
-    });
+    })
   }
 
   toJSON(): ReserveJSON {
@@ -185,17 +199,23 @@ export class Reserve {
       farmCollateral: this.farmCollateral.toString(),
       farmDebt: this.farmDebt.toString(),
       liquidity: this.liquidity.toJSON(),
-      reserveLiquidityPadding: this.reserveLiquidityPadding.map((item) => item.toString()),
+      reserveLiquidityPadding: this.reserveLiquidityPadding.map((item) =>
+        item.toString()
+      ),
       collateral: this.collateral.toJSON(),
-      reserveCollateralPadding: this.reserveCollateralPadding.map((item) => item.toString()),
+      reserveCollateralPadding: this.reserveCollateralPadding.map((item) =>
+        item.toString()
+      ),
       config: this.config.toJSON(),
       configPadding: this.configPadding.map((item) => item.toString()),
-      borrowedAmountOutsideElevationGroup: this.borrowedAmountOutsideElevationGroup.toString(),
-      borrowedAmountsAgainstThisReserveInElevationGroups: this.borrowedAmountsAgainstThisReserveInElevationGroups.map(
-        (item) => item.toString()
-      ),
+      borrowedAmountOutsideElevationGroup:
+        this.borrowedAmountOutsideElevationGroup.toString(),
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        this.borrowedAmountsAgainstThisReserveInElevationGroups.map((item) =>
+          item.toString()
+        ),
       padding: this.padding.map((item) => item.toString()),
-    };
+    }
   }
 
   static fromJSON(obj: ReserveJSON): Reserve {
@@ -206,16 +226,23 @@ export class Reserve {
       farmCollateral: new PublicKey(obj.farmCollateral),
       farmDebt: new PublicKey(obj.farmDebt),
       liquidity: types.ReserveLiquidity.fromJSON(obj.liquidity),
-      reserveLiquidityPadding: obj.reserveLiquidityPadding.map((item) => new BN(item)),
+      reserveLiquidityPadding: obj.reserveLiquidityPadding.map(
+        (item) => new BN(item)
+      ),
       collateral: types.ReserveCollateral.fromJSON(obj.collateral),
-      reserveCollateralPadding: obj.reserveCollateralPadding.map((item) => new BN(item)),
+      reserveCollateralPadding: obj.reserveCollateralPadding.map(
+        (item) => new BN(item)
+      ),
       config: types.ReserveConfig.fromJSON(obj.config),
       configPadding: obj.configPadding.map((item) => new BN(item)),
-      borrowedAmountOutsideElevationGroup: new BN(obj.borrowedAmountOutsideElevationGroup),
-      borrowedAmountsAgainstThisReserveInElevationGroups: obj.borrowedAmountsAgainstThisReserveInElevationGroups.map(
-        (item) => new BN(item)
+      borrowedAmountOutsideElevationGroup: new BN(
+        obj.borrowedAmountOutsideElevationGroup
       ),
+      borrowedAmountsAgainstThisReserveInElevationGroups:
+        obj.borrowedAmountsAgainstThisReserveInElevationGroups.map(
+          (item) => new BN(item)
+        ),
       padding: obj.padding.map((item) => new BN(item)),
-    });
+    })
   }
 }