@kamino-finance/klend-sdk 6.0.5 → 7.0.0

package/src/classes/vault.ts

@@ -87,12 +87,14 @@ import {
   AcceptVaultOwnershipIxs,
   APYs,
   DepositIxs,
+  DisinvestAllReservesIxs,
   InitVaultIxs,
   ReserveAllocationOverview,
   SyncVaultLUTIxs,
   UpdateReserveAllocationIxs,
   UpdateVaultConfigIxs,
   UserSharesForVault,
+  VaultComputedAllocation,
   WithdrawAndBlockReserveIxs,
   WithdrawIxs,
 } from './vault_types';
@@ -121,6 +123,7 @@ import { noopSigner } from '../utils/signer';
 import { getExtendLookupTableInstruction } from '@solana-program/address-lookup-table';
 import { Farms } from '@kamino-finance/farms-sdk';
 import { getFarmIncentives } from '@kamino-finance/farms-sdk/dist/utils/apy';
+import { computeReservesAllocation } from '../utils/vaultAllocation';
 
 export const kaminoVaultId = address('KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd');
 export const kaminoVaultStagingId = address('stKvQfwRsQiKnLtMNVLHKS3exFJmZFsgfzBPWHECUYK');
@@ -453,6 +456,50 @@ export class KaminoVaultClient {
     return updateReserveAllocationIxs;
   }
 
+  /**
+   * This method updates the unallocated weight and cap of a vault (both are optional, if not provided the current values will be used)
+   * @param vault - the vault to update the unallocated weight and cap for
+   * @param [vaultAdminAuthority] - vault admin - a noop vaultAdminAuthority is provided when absent for multisigs
+   * @param [unallocatedWeight] - the new unallocated weight to set. If not provided, the current unallocated weight will be used
+   * @param [unallocatedCap] - the new unallocated cap to set. If not provided, the current unallocated cap will be used
+   * @returns - a list of instructions to update the unallocated weight and cap
+   */
+  async updateVaultUnallocatedWeightAndCapIxs(
+    vault: KaminoVault,
+    vaultAdminAuthority?: TransactionSigner,
+    unallocatedWeight?: BN,
+    unallocatedCap?: BN
+  ) {
+    const vaultState = await vault.getState(this.getConnection());
+
+    const unallocatedWeightToUse = unallocatedWeight ? unallocatedWeight : vaultState.unallocatedWeight;
+    const unallocatedCapToUse = unallocatedCap ? unallocatedCap : vaultState.unallocatedTokensCap;
+
+    const ixs: IInstruction[] = [];
+
+    if (!unallocatedWeightToUse.eq(vaultState.unallocatedWeight)) {
+      const updateVaultUnallocatedWeightIx = await this.updateVaultConfigIxs(
+        vault,
+        new VaultConfigField.UnallocatedWeight(),
+        unallocatedWeightToUse.toString(),
+        vaultAdminAuthority
+      );
+      ixs.push(updateVaultUnallocatedWeightIx.updateVaultConfigIx);
+    }
+
+    if (!unallocatedCapToUse.eq(vaultState.unallocatedTokensCap)) {
+      const updateVaultUnallocatedCapIx = await this.updateVaultConfigIxs(
+        vault,
+        new VaultConfigField.UnallocatedTokensCap(),
+        unallocatedCapToUse.toString(),
+        vaultAdminAuthority
+      );
+      ixs.push(updateVaultUnallocatedCapIx.updateVaultConfigIx);
+    }
+
+    return ixs;
+  }
+
   /**
    * This method withdraws all the funds from a reserve and blocks it from being invested by setting its weight and ctoken allocation to 0
    * @param vault - the vault to withdraw the funds from
@@ -506,7 +553,7 @@ export class KaminoVaultClient {
    * @param vault - the vault to withdraw the invested funds from
    * @param [vaultReservesMap] - optional parameter to pass a map of the vault reserves. If not provided, the reserves will be loaded from the vault
    * @param [payer] - optional parameter to pass a different payer for the transaction. If not provided, the admin of the vault will be used; this is the payer for the invest ixs and it should have an ATA and some lamports (2x no_of_reserves) of the token vault
-   * @returns - a struct with an instruction to update the reserve allocation and an optional list of instructions to update the lookup table for the allocation changes
+   * @returns - a struct with an instruction to update the reserve allocations (set weight and ctoken allocation to 0) and an a list of instructions to disinvest the funds in the reserves
    */
   async withdrawEverythingFromAllReservesAndBlockInvest(
     vault: KaminoVault,
@@ -544,6 +591,59 @@ export class KaminoVaultClient {
     return withdrawAndBlockReserveIxs;
   }
 
+  /**
+   * This method disinvests all the funds from all the reserves and set their weight to 0; for vaults that are managed by external bot/crank, the bot can change the weight and invest in the reserves again
+   * @param vault - the vault to disinvest the invested funds from
+   * @param [vaultReservesMap] - optional parameter to pass a map of the vault reserves. If not provided, the reserves will be loaded from the vault
+   * @param [payer] - optional parameter to pass a different payer for the transaction. If not provided, the admin of the vault will be used; this is the payer for the invest ixs and it should have an ATA and some lamports (2x no_of_reserves) of the token vault
+   * @returns - a struct with an instruction to update the reserve allocations to 0 weight and a list of instructions to disinvest the funds in the reserves
+   */
+  async disinvestAllReservesIxs(
+    vault: KaminoVault,
+    vaultReservesMap?: Map<Address, KaminoReserve>,
+    payer?: TransactionSigner
+  ): Promise<DisinvestAllReservesIxs> {
+    const vaultState = await vault.getState(this.getConnection());
+
+    const reserves = this.getVaultReserves(vaultState);
+    const disinvestAllReservesIxs: DisinvestAllReservesIxs = {
+      updateReserveAllocationIxs: [],
+      investIxs: [],
+    };
+
+    if (!vaultReservesMap) {
+      vaultReservesMap = await this.loadVaultReserves(vaultState);
+    }
+
+    for (const reserve of reserves) {
+      const reserveWithAddress: ReserveWithAddress = {
+        address: reserve,
+        state: vaultReservesMap.get(reserve)!.state,
+      };
+      const existingReserveAllocation = vaultState.vaultAllocationStrategy.find(
+        (allocation) => allocation.reserve === reserve
+      );
+      if (!existingReserveAllocation) {
+        continue;
+      }
+      const reserveAllocationConfig = new ReserveAllocationConfig(
+        reserveWithAddress,
+        0,
+        new Decimal(existingReserveAllocation.tokenAllocationCap.toString())
+      );
+
+      // update allocation to have 0 weight and 0 cap
+      const updateAllocIxs = await this.updateReserveAllocationIxs(vault, reserveAllocationConfig, payer);
+      disinvestAllReservesIxs.updateReserveAllocationIxs.push(updateAllocIxs.updateReserveAllocationIx);
+    }
+
+    const investPayer = payer ? payer : noopSigner(vaultState.vaultAdminAuthority);
+    const investIxs = await this.investAllReservesIxs(investPayer, vault);
+    disinvestAllReservesIxs.investIxs = investIxs;
+
+    return disinvestAllReservesIxs;
+  }
+
   /**
    * This method removes a reserve from the vault allocation strategy if already part of the allocation strategy
    * @param vault - vault to remove the reserve from
@@ -1354,7 +1454,7 @@ export class KaminoVaultClient {
     for (let index = 0; index < allReserves.length; index++) {
       const reservePubkey = allReserves[index];
       const reserveState = allReservesStateMap.get(reservePubkey)!;
-      const computedAllocation = computedReservesAllocation.get(reservePubkey)!;
+      const computedAllocation = computedReservesAllocation.targetReservesAllocation.get(reservePubkey)!;
       const currentCTokenAllocation = curentVaultAllocations.get(reservePubkey)!.ctokenAllocation;
       const currentAllocationCap = curentVaultAllocations.get(reservePubkey)!.tokenAllocationCap;
 
@@ -1790,7 +1890,10 @@ export class KaminoVaultClient {
     slot?: Slot,
     vaultReserves?: Map<Address, KaminoReserve>,
     currentSlot?: Slot
-  ): Promise<Map<Address, Decimal>> {
+  ): Promise<VaultComputedAllocation> {
+    // 1. Read the states
+    const holdings = await this.getVaultHoldings(vaultState, slot, vaultReserves, currentSlot);
+
     // if there are no vault reserves or all have weight 0 everything has to be in Available
     const allReservesPubkeys = this.getVaultReserves(vaultState);
     const reservesAllocations = this.getVaultAllocations(vaultState);
@@ -1803,50 +1906,30 @@ export class KaminoVaultClient {
       allReservesPubkeys.forEach((reserve) => {
         computedHoldings.set(reserve, new Decimal(0));
       });
-      return computedHoldings;
+      return {
+        targetUnallocatedAmount: holdings.totalAUMIncludingFees.sub(holdings.pendingFees),
+        targetReservesAllocation: computedHoldings,
+      };
     }
 
-    const holdings = await this.getVaultHoldings(vaultState, slot, vaultReserves, currentSlot);
     const initialVaultAllocations = this.getVaultAllocations(vaultState);
 
-    const allReserves = this.getVaultReserves(vaultState);
-
-    let totalAllocation = new Decimal(0);
-    initialVaultAllocations.forEach((allocation) => {
-      totalAllocation = totalAllocation.add(allocation.targetWeight);
-    });
-    const expectedHoldingsDistribution = new Map<Address, Decimal>();
-    allReserves.forEach((reserve) => {
-      expectedHoldingsDistribution.set(reserve, new Decimal(0));
-    });
-
-    let totalLeftToInvest = holdings.totalAUMIncludingFees.sub(holdings.pendingFees);
-    let currentAllocationSum = totalAllocation;
-    const ONE = new Decimal(1);
-    while (totalLeftToInvest.gt(ONE)) {
-      const totalLeftover = totalLeftToInvest;
-      for (const reserve of allReserves) {
-        const reserveWithWeight = initialVaultAllocations.get(reserve);
-        const targetAllocation = reserveWithWeight!.targetWeight.mul(totalLeftover).div(currentAllocationSum);
-        const reserveCap = reserveWithWeight!.tokenAllocationCap;
-        let amountToInvest = Decimal.min(targetAllocation, totalLeftToInvest);
-        if (reserveCap.gt(ZERO)) {
-          amountToInvest = Decimal.min(amountToInvest, reserveCap);
-        }
-        totalLeftToInvest = totalLeftToInvest.sub(amountToInvest);
-        if (amountToInvest.eq(reserveCap) && reserveCap.gt(ZERO)) {
-          currentAllocationSum = currentAllocationSum.sub(reserveWithWeight!.targetWeight);
-        }
-        const reserveHasPreallocation = expectedHoldingsDistribution.has(reserve);
-        if (reserveHasPreallocation) {
-          expectedHoldingsDistribution.set(reserve, expectedHoldingsDistribution.get(reserve)!.add(amountToInvest));
-        } else {
-          expectedHoldingsDistribution.set(reserve, amountToInvest);
-        }
-      }
-    }
+    // 2. Compute the allocation
+    return this.computeReservesAllocation(
+      holdings.totalAUMIncludingFees.sub(holdings.pendingFees),
+      new Decimal(vaultState.unallocatedWeight.toString()),
+      new Decimal(vaultState.unallocatedTokensCap.toString()),
+      initialVaultAllocations
+    );
+  }
 
-    return expectedHoldingsDistribution;
+  private computeReservesAllocation(
+    vaultAUM: Decimal,
+    vaultUnallocatedWeight: Decimal,
+    vaultUnallocatedCap: Decimal,
+    initialVaultAllocations: Map<Address, ReserveAllocationOverview>
+  ) {
+    return computeReservesAllocation(vaultAUM, vaultUnallocatedWeight, vaultUnallocatedCap, initialVaultAllocations);
   }
 
   /**

package/src/classes/vault_types.ts

@@ -1,4 +1,4 @@
-import { IInstruction } from '@solana/kit';
+import { Address, IInstruction } from '@solana/kit';
 import Decimal from 'decimal.js/decimal';
 
 /** the populateLUTIxs should be executed in a separate transaction as we cannot create and populate a lookup table in the same tx */
@@ -27,11 +27,21 @@ export type WithdrawAndBlockReserveIxs = {
   investIxs: IInstruction[];
 };
 
+export type DisinvestAllReservesIxs = {
+  updateReserveAllocationIxs: IInstruction[];
+  investIxs: IInstruction[];
+};
+
 export type UpdateVaultConfigIxs = {
   updateVaultConfigIx: IInstruction;
   updateLUTIxs: IInstruction[];
 };
 
+export type VaultComputedAllocation = {
+  targetUnallocatedAmount: Decimal;
+  targetReservesAllocation: Map<Address, Decimal>;
+};
+
 /** If there are ixs to setup the LUT it means it doesn't already exist and it needs to be created in a separate tx before inserting into it */
 export type SyncVaultLUTIxs = {
   setupLUTIfNeededIxs: IInstruction[];

package/src/client/commands/borrow.ts

@@ -10,6 +10,7 @@ export async function borrow(env: CliEnv, mode: SendTxMode, token: string, borro
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
+  const scope = new Scope('mainnet-beta', env.c.rpc);
   const kaminoAction = await KaminoAction.buildBorrowTxns(
     kaminoMarket,
     borrowAmount,
@@ -17,7 +18,7 @@ export async function borrow(env: CliEnv, mode: SendTxMode, token: string, borro
     signer,
     new VanillaObligation(STAGING_LENDING_MARKET),
     true,
-    { scope: new Scope('mainnet-beta', env.c.rpc), scopeFeed: 'hubble' }
+    { scope, scopeConfigurations: await scope.getAllConfigurations() }
   );
   console.log('User obligation', await kaminoAction.getObligationPda());
 

package/src/client/commands/deposit.ts

@@ -10,6 +10,7 @@ export async function deposit(env: CliEnv, mode: SendTxMode, token: string, depo
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
+  const scope = new Scope('mainnet-beta', env.c.rpc);
   const kaminoAction = await KaminoAction.buildDepositTxns(
     kaminoMarket,
     depositAmount,
@@ -17,7 +18,7 @@ export async function deposit(env: CliEnv, mode: SendTxMode, token: string, depo
     signer,
     new VanillaObligation(STAGING_LENDING_MARKET),
     true,
-    { scope: new Scope('mainnet-beta', env.c.rpc), scopeFeed: 'hubble' }
+    { scope, scopeConfigurations: await scope.getAllConfigurations() }
   );
   console.log('User obligation', await kaminoAction.getObligationPda());
 

package/src/client/commands/repay.ts

@@ -10,6 +10,7 @@ export async function repay(env: CliEnv, mode: SendTxMode, token: string, borrow
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
+  const scope = new Scope('mainnet-beta', env.c.rpc);
   const kaminoAction = await KaminoAction.buildRepayTxns(
     kaminoMarket,
     borrowAmount,
@@ -17,7 +18,7 @@ export async function repay(env: CliEnv, mode: SendTxMode, token: string, borrow
     signer,
     new VanillaObligation(STAGING_LENDING_MARKET),
     true,
-    { scope: new Scope('mainnet-beta', env.c.rpc), scopeFeed: 'hubble' },
+    { scope, scopeConfigurations: await scope.getAllConfigurations() },
     await env.c.rpc.getSlot().send()
   );
   console.log('User obligation', await kaminoAction.getObligationPda());

package/src/client/commands/withdraw.ts

@@ -10,6 +10,7 @@ export async function withdraw(env: CliEnv, mode: SendTxMode, token: string, dep
   const signer = await env.getSigner();
   const programId = getProgramId('staging');
   const kaminoMarket = await getMarket(env.c.rpc, programId);
+  const scope = new Scope('mainnet-beta', env.c.rpc);
   const kaminoAction = await KaminoAction.buildWithdrawTxns(
     kaminoMarket,
     depositAmount,
@@ -17,7 +18,7 @@ export async function withdraw(env: CliEnv, mode: SendTxMode, token: string, dep
     signer,
     new VanillaObligation(STAGING_LENDING_MARKET),
     true,
-    { scope: new Scope('mainnet-beta', env.c.rpc), scopeFeed: 'hubble' }
+    { scope, scopeConfigurations: await scope.getAllConfigurations() }
   );
   console.log('User obligation', await kaminoAction.getObligationPda());
 

package/src/idl/kvault.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.1.0",
+  "version": "1.0.0",
   "name": "kamino_vault",
   "instructions": [
     {
@@ -880,7 +880,7 @@
             "type": {
               "array": [
                 "u64",
-                116
+                115
               ]
             }
           },
@@ -967,7 +967,7 @@
             "type": "u64"
           },
           {
-            "name": "padding0",
+            "name": "unallocatedWeight",
             "type": "u64"
           },
           {
@@ -1068,7 +1068,7 @@
             "type": "u64"
           },
           {
-            "name": "padding2",
+            "name": "unallocatedTokensCap",
             "type": "u64"
           },
           {
@@ -1236,7 +1236,7 @@
             "type": "u16"
           },
           {
-            "name": "reserved2",
+            "name": "reserved1",
             "docs": [
               "[DEPRECATED] Space that used to hold 2 fields:",
               "- Boost for side (debt or collateral)",
@@ -1422,13 +1422,15 @@
             "type": "u8"
           },
           {
-            "name": "reserved1",
-            "type": {
-              "array": [
-                "u8",
-                1
-              ]
-            }
+            "name": "proposerAuthorityLocked",
+            "docs": [
+              "Boolean flag indicating whether the reserve is locked for the proposer authority.",
+              "",
+              "Once the proposer have finished preparing the reserve, it must be locked to prevent",
+              "further changes to the reserve configuration allowing review and voting on the proposal",
+              "without alteration during the voting period."
+            ],
+            "type": "u8"
           },
           {
             "name": "borrowLimitOutsideElevationGroup",
@@ -1461,6 +1463,15 @@
               "Only relevant when `autodeleverage_enabled == 1`, and must not be 0 in such case."
             ],
             "type": "u64"
+          },
+          {
+            "name": "debtMaturityTimestamp",
+            "docs": [
+              "The timestamp at which all [Obligation::borrows] using this reserve become liquidatable",
+              "(on the same terms as reserve-wide deleveraging).",
+              "Inactive when zeroed (i.e. debt never matures)."
+            ],
+            "type": "u64"
           }
         ]
       }
@@ -1954,6 +1965,12 @@
           },
           {
             "name": "AllocationAdmin"
+          },
+          {
+            "name": "UnallocatedWeight"
+          },
+          {
+            "name": "UnallocatedTokensCap"
           }
         ]
       }
@@ -2332,6 +2349,11 @@
       "code": 7047,
       "name": "ReserveHasNonZeroAllocationOrCTokens",
       "msg": "Reserve has non-zero allocation or ctokens so cannot be removed"
+    },
+    {
+      "code": 7048,
+      "name": "DepositAmountGreaterThanRequestedAmount",
+      "msg": "Deposit amount is greater than requested amount"
     }
   ]
 }

package/src/leverage/operations.ts

@@ -1676,18 +1676,17 @@ export const getScopeRefreshIx = async (
           ]),
         ]
       : [...new Set<Address>([collReserve.address, debtReserve.address])];
-  const tokenIds = getTokenIdsForScopeRefresh(market, allReserves);
 
   const scopeRefreshIxs: IInstruction[] = [];
-  if (tokenIds.length > 0 && scopeRefreshConfig) {
-    scopeRefreshIxs.push(
-      await scopeRefreshConfig.scope.refreshPriceListIx(
-        {
-          feed: scopeRefreshConfig.scopeFeed,
-        },
-        tokenIds
-      )
-    );
+  const scopeTokensMap = getTokenIdsForScopeRefresh(market, allReserves);
+
+  if (scopeTokensMap.size > 0 && scopeRefreshConfig) {
+    for (const [configPubkey, config] of scopeRefreshConfig.scopeConfigurations) {
+      const tokenIds = scopeTokensMap.get(config.oraclePrices);
+      if (tokenIds && tokenIds.length > 0) {
+        scopeRefreshIxs.push(await scopeRefreshConfig.scope.refreshPriceListIx({ config: configPubkey }, tokenIds));
+      }
+    }
   }
 
   return scopeRefreshIxs;

package/src/manager/client_kamino_manager.ts

@@ -1502,8 +1502,9 @@ async function main() {
 
   commands
     .command('get-oracle-mappings')
+    .requiredOption('--lending-market <string>', 'Lending Market Address')
     .option(`--staging`, 'If true, will use the staging programs')
-    .action(async ({ staging }) => {
+    .action(async ({ staging, lendingMarket }) => {
       const env = await initEnv(staging);
       const kaminoManager = new KaminoManager(
         env.c.rpc,
@@ -1511,10 +1512,21 @@ async function main() {
         env.klendProgramId,
         env.kvaultProgramId
       );
+      const market = await KaminoMarket.load(
+        env.c.rpc,
+        address(lendingMarket),
+        DEFAULT_RECENT_SLOT_DURATION_MS,
+        env.klendProgramId
+      );
+      if (!market) {
+        throw Error(`Lending market ${lendingMarket} not found`);
+      }
 
       console.log('Getting  oracle mappings');
-      const oracleConfigs = await kaminoManager.getScopeOracleConfigs();
-      console.log('oracleConfigs', JSON.parse(JSON.stringify(oracleConfigs)));
+      const oracleConfigs = await kaminoManager.getScopeOracleConfigs(market);
+      for (const [oraclePrices, configs] of oracleConfigs.entries()) {
+        console.log(`OraclePrices pubkey: ${oraclePrices}`, 'Configs:', JSON.parse(JSON.stringify(configs)));
+      }
     });
 
   commands

package/src/utils/index.ts

@@ -14,3 +14,4 @@ export * from './lookupTable';
 export * from './managerTypes';
 export * from './fuzz';
 export * from './rpc';
+export * from './map';

package/src/utils/managerTypes.ts

@@ -13,7 +13,7 @@ import {
   WithdrawalCaps,
 } from '../@codegen/klend/types';
 import Decimal from 'decimal.js';
-import { Fraction, ZERO_FRACTION } from '../classes/fraction';
+import { Fraction, ZERO_FRACTION } from '../classes';
 import BN from 'bn.js';
 import { numberToLamportsDecimal } from '../classes';
 import { NULL_PUBKEY } from './pubkey';
@@ -22,7 +22,6 @@ import { OracleType } from '@kamino-finance/scope-sdk/dist/@codegen/scope/types'
 import { LendingMarket } from '../lib';
 
 export type ScopeOracleConfig = {
-  scopePriceConfigAddress: Address;
   name: string;
   oracleType: string;
   oracleId: number;
@@ -80,7 +79,7 @@ export class AssetReserveConfig implements AssetConfig {
     this.mintTokenProgram = fields.mintTokenProgram;
 
     // TODO: verify defaults and ensure opinionated
-    this.assetReserveConfigParams = DefaultConfigParams;
+    this.assetReserveConfigParams = getDefaultConfigParams();
     this.assetReserveConfigParams.priceFeed = fields.priceFeed;
     this.assetReserveConfigParams.loanToValuePct = fields.loanToValuePct;
     this.assetReserveConfigParams.liquidationThresholdPct = fields.liquidationThresholdPct;
@@ -114,7 +113,7 @@ export class AssetReserveConfigCli implements AssetConfig {
     this.reserveConfig = reserveConfig;
     this.tokenName = '';
     this.mintDecimals = 0;
-    this.assetReserveConfigParams = DefaultConfigParams;
+    this.assetReserveConfigParams = getDefaultConfigParams();
     this.mint = mint;
     this.mintTokenProgram = mintTokenProgram;
   }
@@ -160,7 +159,7 @@ export class CollateralConfig implements AssetConfig {
     this.mintTokenProgram = fields.mintTokenProgram;
 
     // TODO: verify defaults and ensure opinionated
-    this.assetReserveConfigParams = DefaultConfigParams;
+    this.assetReserveConfigParams = getDefaultConfigParams();
     this.assetReserveConfigParams.priceFeed = fields.priceFeed;
     this.assetReserveConfigParams.loanToValuePct = fields.loanToValuePct;
     this.assetReserveConfigParams.liquidationThresholdPct = fields.liquidationThresholdPct;
@@ -207,7 +206,7 @@ export class DebtConfig implements AssetConfig {
     this.debtWithdrawalCapConfigCapacity = fields.debtWithdrawalCapConfigCapacity;
 
     // TODO: verify defaults and ensure opinionated
-    this.assetReserveConfigParams = DefaultConfigParams;
+    this.assetReserveConfigParams = getDefaultConfigParams();
     this.assetReserveConfigParams.priceFeed = fields.priceFeed;
     this.assetReserveConfigParams.borrowRateCurve = fields.borrowRateCurve;
   }
@@ -254,28 +253,30 @@ export type AssetReserveConfigParams = {
   borrowRateCurve: BorrowRateCurve;
 };
 
-export const DefaultConfigParams: AssetReserveConfigParams = {
-  loanToValuePct: 70,
-  maxLiquidationBonusBps: 500,
-  minLiquidationBonusBps: 200,
-  badDebtLiquidationBonusBps: 10,
-  liquidationThresholdPct: 75,
-  borrowFeeSf: ZERO_FRACTION,
-  flashLoanFeeSf: ZERO_FRACTION,
-  protocolTakeRate: 0,
-  elevationGroups: new Array(20).fill(0),
-  priceFeed: null,
-  borrowLimit: new Decimal(1000.0),
-  depositLimit: new Decimal(1000.0),
-  borrowRateCurve: new BorrowRateCurve({
-    points: [
-      new CurvePoint({ utilizationRateBps: 0, borrowRateBps: 1000 }),
-      new CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 1000 }),
-      ...Array(9).fill(new CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 1000 })),
-    ],
-  } as BorrowRateCurveFields),
-  maxAgePriceSeconds: 180,
-  maxAgeTwapSeconds: 240,
+export const getDefaultConfigParams = (): AssetReserveConfigParams => {
+  return {
+    loanToValuePct: 70,
+    maxLiquidationBonusBps: 500,
+    minLiquidationBonusBps: 200,
+    badDebtLiquidationBonusBps: 10,
+    liquidationThresholdPct: 75,
+    borrowFeeSf: ZERO_FRACTION,
+    flashLoanFeeSf: ZERO_FRACTION,
+    protocolTakeRate: 0,
+    elevationGroups: new Array(20).fill(0),
+    priceFeed: null,
+    borrowLimit: new Decimal(1000.0),
+    depositLimit: new Decimal(1000.0),
+    borrowRateCurve: new BorrowRateCurve({
+      points: [
+        new CurvePoint({ utilizationRateBps: 0, borrowRateBps: 1000 }),
+        new CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 1000 }),
+        ...Array(9).fill(new CurvePoint({ utilizationRateBps: 10000, borrowRateBps: 1000 })),
+      ],
+    } as BorrowRateCurveFields),
+    maxAgePriceSeconds: 180,
+    maxAgeTwapSeconds: 240,
+  };
 };
 
 export const encodeTokenName = (tokenName: string): number[] => {

package/src/utils/map.ts

@@ -0,0 +1,8 @@
+export function setOrAppend<K, V>(map: Map<K, V[]>, key: K, value: V): void {
+  const existing = map.get(key);
+  if (existing) {
+    existing.push(value);
+  } else {
+    map.set(key, [value]);
+  }
+}

package/src/utils/oracle.ts

@@ -7,11 +7,12 @@ import { parseTokenSymbol } from '../classes';
 import { Reserve } from '../lib';
 import { batchFetch } from '@kamino-finance/kliquidity-sdk';
 import BN from 'bn.js';
-import { priceUpdateV2 } from '../@codegen/pyth_rec/accounts/priceUpdateV2';
-import { AggregatorAccountData } from '../@codegen/switchboard_v2/accounts/AggregatorAccountData';
+import { priceUpdateV2 } from '../@codegen/pyth_rec/accounts';
+import { AggregatorAccountData } from '../@codegen/switchboard_v2/accounts';
 import { Buffer } from 'buffer';
 import { getLatestAggregatorValue } from './switchboard';
 import { PROGRAM_ID as SWITCHBOARD_V2_PROGRAM_ID } from '../@codegen/switchboard_v2/programId';
+import { Configuration } from '@kamino-finance/scope-sdk/dist/@codegen/scope/accounts/Configuration';
 
 // validate price confidence - confidence/price ratio should be less than 2%
 export const MAX_CONFIDENCE_PERCENTAGE: Decimal = new Decimal('2');
@@ -39,7 +40,7 @@ export type CandidatePrice = {
 
 export type ScopePriceRefreshConfig = {
   scope: Scope;
-  scopeFeed: string;
+  scopeConfigurations: [Address, Configuration][];
 };
 
 export function getTokenOracleDataSync(allOracleAccounts: AllOracleAccounts, reserves: Reserve[]) {

package/src/utils/vault.ts

@@ -21,7 +21,8 @@ export function decodeVaultState(data: Buffer): VaultState {
     tokenAvailable: dec.tokenAvailable,
     sharesIssued: dec.sharesIssued,
     availableCrankFunds: dec.availableCrankFunds,
-    padding0: dec.padding0,
+    unallocatedWeight: dec.unallocatedWeight,
+    unallocatedTokensCap: dec.unallocatedTokensCap,
     performanceFeeBps: dec.performanceFeeBps,
     managementFeeBps: dec.managementFeeBps,
     lastFeeChargeTimestamp: dec.lastFeeChargeTimestamp,
@@ -44,7 +45,6 @@ export function decodeVaultState(data: Buffer): VaultState {
     vaultLookupTable: dec.vaultLookupTable,
     vaultFarm: dec.vaultFarm,
     creationTimestamp: dec.creationTimestamp,
-    padding2: dec.padding2,
     allocationAdmin: dec.allocationAdmin,
     padding3: dec.padding3,
   });