@kamino-finance/klend-sdk 5.2.13 → 5.3.0

package/src/lending_operations/repay_with_collateral_operations.ts

@@ -29,6 +29,13 @@ export type RepayWithCollIxsResponse<QuoteResponse> = {
 export type InitialInputs<QuoteResponse> = {
   debtRepayAmountLamports: Decimal;
   flashRepayAmountLamports: Decimal;
+  /**
+   * The amount of collateral available to withdraw, if this is less than the swap input amount, then the swap may fail due to slippage, or tokens may be debited from the user's ATA, so the caller needs to check this
+   */
+  maxCollateralWithdrawLamports: Decimal;
+  /**
+   * The quote from the provided quoter
+   */
   swapQuote: SwapQuote<QuoteResponse>;
   currentSlot: number;
   klendAccounts: Array<PublicKey>;
@@ -93,9 +100,9 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
   }
   const { withdrawableCollLamports } = calcMaxWithdrawCollateral(
     kaminoMarket,
+    obligation,
     collReserve.address,
     debtReserve.address,
-    obligation,
     repayAmountLamports
   );
 
@@ -156,6 +163,7 @@ export async function getRepayWithCollSwapInputs<QuoteResponse>({
     initialInputs: {
       debtRepayAmountLamports: repayAmountLamports,
       flashRepayAmountLamports,
+      maxCollateralWithdrawLamports: withdrawableCollLamports,
       swapQuote,
       currentSlot,
       klendAccounts: uniqueKlendAccounts,
@@ -196,18 +204,30 @@ export async function getRepayWithCollIxs<QuoteResponse>({
     budgetAndPriorityFeeIxs,
     scopeRefresh,
   });
-  const { debtRepayAmountLamports, flashRepayAmountLamports, swapQuote } = initialInputs;
+  const { debtRepayAmountLamports, flashRepayAmountLamports, maxCollateralWithdrawLamports, swapQuote } = initialInputs;
   const { inputAmountLamports: collSwapInLamports } = swapInputs;
 
   const collReserve = kaminoMarket.getReserveByMint(collTokenMint)!;
   const debtReserve = kaminoMarket.getReserveByMint(debtTokenMint)!;
 
+  // the client should use these values to prevent this input, but the tx may succeed, so we don't want to fail
+  // there is also a chance that the tx will consume debt token from the user's ata which they would not expect
+  if (collSwapInLamports.greaterThan(maxCollateralWithdrawLamports)) {
+    logger(
+      `Collateral swap in amount ${collSwapInLamports} exceeds max withdrawable collateral ${maxCollateralWithdrawLamports}, tx may fail with slippage`
+    );
+    swapInputs.inputAmountLamports = maxCollateralWithdrawLamports;
+  }
+
+  const actualSwapInLamports = Decimal.min(collSwapInLamports, maxCollateralWithdrawLamports);
   logger(
-    `Expected to swap in: ${collSwapInLamports.div(collReserve.getMintFactor())} ${
+    `Expected to swap in: ${actualSwapInLamports.div(collReserve.getMintFactor())} ${
       collReserve.symbol
     }, for: ${flashRepayAmountLamports.div(debtReserve.getMintFactor())} ${debtReserve.symbol}, quoter px: ${
       swapQuote.priceAInB
-    } ${debtReserve.symbol}/${collReserve.symbol}`
+    } ${debtReserve.symbol}/${collReserve.symbol}, required px: ${flashRepayAmountLamports
+      .div(debtReserve.getMintFactor())
+      .div(actualSwapInLamports.div(collReserve.getMintFactor()))} ${debtReserve.symbol}/${collReserve.symbol}`
   );
 
   const swapResponse = await swapper(swapInputs, initialInputs.klendAccounts, swapQuote);

package/src/leverage/operations.ts

@@ -1045,7 +1045,7 @@ export async function getAdjustLeverageSwapInputs<QuoteResponse>({
 
     const swapInputAmount = toLamports(
       !collIsKtoken ? calcs.borrowAmount : calcs.amountToFlashBorrowDebt,
-      debtReserve.stats.decimals,
+      debtReserve.stats.decimals
     ).ceil();
 
     const swapInputsForQuote: SwapInputs = {

package/src/pyth/accounts/PriceUpdateV2.ts

@@ -0,0 +1,110 @@
+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';
+
+export const PYTH_RECEIVER_PROGRAM_ID = new PublicKey('rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ');
+
+export interface PriceUpdateV2Fields {
+  writeAuthority: PublicKey;
+  verificationLevel: types.VerificationLevelKind;
+  priceMessage: types.PriceFeedMessageFields;
+  postedSlot: BN;
+}
+
+export interface PriceUpdateV2JSON {
+  writeAuthority: string;
+  verificationLevel: types.VerificationLevelJSON;
+  priceMessage: types.PriceFeedMessageJSON;
+  postedSlot: string;
+}
+
+export class PriceUpdateV2 {
+  readonly writeAuthority: PublicKey;
+  readonly verificationLevel: types.VerificationLevelKind;
+  readonly priceMessage: types.PriceFeedMessage;
+  readonly postedSlot: BN;
+
+  // static readonly discriminator = Buffer.from([
+  //   43, 242, 204, 202, 26, 247, 59, 127,
+  // ])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey('writeAuthority'),
+    borsh.u8('verificationLevel'),
+    types.PriceFeedMessage.layout('priceMessage'),
+    borsh.u64('postedSlot'),
+  ]);
+
+  constructor(fields: PriceUpdateV2Fields) {
+    this.writeAuthority = fields.writeAuthority;
+    this.verificationLevel = fields.verificationLevel;
+    this.priceMessage = new types.PriceFeedMessage({ ...fields.priceMessage });
+    this.postedSlot = fields.postedSlot;
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PYTH_RECEIVER_PROGRAM_ID
+  ): Promise<PriceUpdateV2 | null> {
+    const info = await c.getAccountInfo(address);
+
+    if (info === null) {
+      return null;
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program");
+    }
+
+    return this.decode(info.data);
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PYTH_RECEIVER_PROGRAM_ID
+  ): Promise<Array<PriceUpdateV2 | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses);
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null;
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program");
+      }
+
+      return this.decode(info.data);
+    });
+  }
+
+  static decode(data: Buffer): PriceUpdateV2 {
+    const dec = PriceUpdateV2.layout.decode(data.slice(8));
+
+    return new PriceUpdateV2({
+      writeAuthority: dec.writeAuthority,
+      verificationLevel: dec.verificationLevel,
+      priceMessage: types.PriceFeedMessage.fromDecoded(dec.priceMessage),
+      postedSlot: dec.postedSlot,
+    });
+  }
+
+  toJSON(): PriceUpdateV2JSON {
+    return {
+      writeAuthority: this.writeAuthority.toString(),
+      verificationLevel: this.verificationLevel.toJSON(),
+      priceMessage: this.priceMessage.toJSON(),
+      postedSlot: this.postedSlot.toString(),
+    };
+  }
+
+  static fromJSON(obj: PriceUpdateV2JSON): PriceUpdateV2 {
+    return new PriceUpdateV2({
+      writeAuthority: new PublicKey(obj.writeAuthority),
+      verificationLevel: types.VerificationLevel.fromJSON(obj.verificationLevel),
+      priceMessage: types.PriceFeedMessage.fromJSON(obj.priceMessage),
+      postedSlot: new BN(obj.postedSlot),
+    });
+  }
+}

package/src/pyth/accounts/index.ts

@@ -0,0 +1,2 @@
+export { PriceUpdateV2 } from './PriceUpdateV2';
+export { PriceUpdateV2Fields, PriceUpdateV2JSON } from './PriceUpdateV2';

package/src/pyth/types/PriceFeedMessage.ts

@@ -0,0 +1,120 @@
+import BN from 'bn.js';
+import * as borsh from '@coral-xyz/borsh';
+
+export interface PriceFeedMessageFields {
+  feedId: number[];
+  price: BN;
+  conf: BN;
+  exponent: number;
+  publishTime: BN;
+  prevPublishTime: BN;
+  emaPrice: BN;
+  emaConf: BN;
+}
+
+export interface PriceFeedMessageJSON {
+  feedId: number[];
+  price: string;
+  conf: string;
+  exponent: number;
+  publishTime: string;
+  prevPublishTime: string;
+  emaPrice: string;
+  emaConf: string;
+}
+
+/** Reserve Withdrawal Caps State */
+export class PriceFeedMessage {
+  readonly feedId: number[];
+  readonly price: BN;
+  readonly conf: BN;
+  readonly exponent: number;
+  readonly publishTime: BN;
+  readonly prevPublishTime: BN;
+  readonly emaPrice: BN;
+  readonly emaConf: BN;
+
+  constructor(fields: PriceFeedMessageFields) {
+    this.feedId = fields.feedId;
+    this.price = fields.price;
+    this.conf = fields.conf;
+    this.exponent = fields.exponent;
+    this.publishTime = fields.publishTime;
+    this.prevPublishTime = fields.prevPublishTime;
+    this.emaPrice = fields.emaPrice;
+    this.emaConf = fields.emaConf;
+  }
+
+  static layout(property?: string) {
+    return borsh.struct(
+      [
+        borsh.array(borsh.u8(), 32, 'feedId'),
+        borsh.i64('price'),
+        borsh.u64('conf'),
+        borsh.i32('exponent'),
+        borsh.i64('publishTime'),
+        borsh.i64('prevPublishTime'),
+        borsh.i64('emaPrice'),
+        borsh.u64('emaConf'),
+      ],
+      property
+    );
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromDecoded(obj: any) {
+    return new PriceFeedMessage({
+      feedId: obj.feedId,
+      price: obj.price,
+      conf: obj.conf,
+      exponent: obj.exponent,
+      publishTime: obj.publishTime,
+      prevPublishTime: obj.prevPublishTime,
+      emaPrice: obj.emaPrice,
+      emaConf: obj.emaConf,
+    });
+  }
+
+  static toEncodable(fields: PriceFeedMessageFields) {
+    return {
+      feedId: fields.feedId,
+      price: fields.price,
+      conf: fields.conf,
+      exponent: fields.exponent,
+      publishTime: fields.publishTime,
+      prevPublishTime: fields.prevPublishTime,
+      emaPrice: fields.emaPrice,
+      emaConf: fields.emaConf,
+    };
+  }
+
+  toJSON(): PriceFeedMessageJSON {
+    return {
+      feedId: this.feedId,
+      price: this.price.toString(),
+      conf: this.conf.toString(),
+      exponent: this.exponent,
+      publishTime: this.publishTime.toString(),
+      prevPublishTime: this.prevPublishTime.toString(),
+      emaPrice: this.emaPrice.toString(),
+      emaConf: this.emaConf.toString(),
+    };
+  }
+
+  static fromJSON(obj: PriceFeedMessageJSON): PriceFeedMessage {
+    return new PriceFeedMessage({
+      feedId: obj.feedId,
+      price: new BN(obj.price),
+      conf: new BN(obj.conf),
+      exponent: obj.exponent,
+      publishTime: new BN(obj.publishTime),
+      prevPublishTime: new BN(obj.prevPublishTime),
+      emaPrice: new BN(obj.emaPrice),
+      emaConf: new BN(obj.emaConf),
+    });
+  }
+
+  toEncodable() {
+    return PriceFeedMessage.toEncodable(this);
+  }
+}

package/src/pyth/types/VerificationLevel.ts

@@ -0,0 +1,98 @@
+import * as types from '../types';
+import * as borsh from '@coral-xyz/borsh';
+
+export type PartialFields = { numSignatures: number };
+export type PartialValue = { numSignatures: number };
+
+export interface PartialJSON {
+  kind: 'Partial';
+  value: { numSignatures: number };
+}
+
+export class Partial {
+  static readonly discriminator = 1;
+  static readonly kind = 'Partial';
+  readonly discriminator = 1;
+  readonly kind = 'Partial';
+  readonly value: PartialValue;
+
+  constructor(value: PartialFields) {
+    this.value = { numSignatures: value.numSignatures };
+  }
+
+  toJSON(): PartialJSON {
+    return {
+      kind: 'Partial',
+      value: {
+        numSignatures: this.value.numSignatures,
+      },
+    };
+  }
+
+  toEncodable() {
+    return {
+      Partial: {
+        numSignatures: this.value.numSignatures,
+      },
+    };
+  }
+}
+
+export interface FullJSON {
+  kind: 'Full';
+}
+
+export class Full {
+  static readonly discriminator = 1;
+  static readonly kind = 'Full';
+  readonly discriminator = 1;
+  readonly kind = 'Full';
+
+  toJSON(): FullJSON {
+    return {
+      kind: 'Full',
+    };
+  }
+
+  toEncodable() {
+    return {
+      Full: {},
+    };
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.VerificationLevelKind {
+  if (typeof obj !== 'object') {
+    throw new Error('Invalid enum object');
+  }
+
+  if ('Partial' in obj) {
+    return new Partial({ numSignatures: obj.Partial.numSignatures });
+  }
+  if ('Full' in obj) {
+    return new Full();
+  }
+
+  throw new Error('Invalid enum object');
+}
+
+export function fromJSON(obj: types.VerificationLevelJSON): types.VerificationLevelKind {
+  switch (obj.kind) {
+    case 'Partial': {
+      return new Partial({ numSignatures: obj.value.numSignatures });
+    }
+    case 'Full': {
+      return new Full();
+    }
+  }
+  throw new Error('Invalid enum object');
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([borsh.u8('numSignatures')], 'Partial'), borsh.struct([], 'Full')]);
+  if (property !== undefined) {
+    return ret.replicate(property);
+  }
+  return ret;
+}

package/src/pyth/types/index.ts

@@ -0,0 +1,9 @@
+export { PriceFeedMessage } from './PriceFeedMessage';
+export type { PriceFeedMessageFields, PriceFeedMessageJSON } from './PriceFeedMessage';
+
+import * as VerificationLevel from './VerificationLevel';
+
+export { VerificationLevel };
+
+export type VerificationLevelKind = VerificationLevel.Partial | VerificationLevel.Full;
+export type VerificationLevelJSON = VerificationLevel.PartialJSON | VerificationLevel.FullJSON;

package/src/referrals/instructions.ts

@@ -41,13 +41,11 @@ export const getInitAllReferrerTokenStateIxns = async ({
 
   tokenStatesToCreate.forEach(([referrerTokenStateAddress, reserveAddress]) => {
     const initReferrerTokenStateIx = initReferrerTokenState(
-      {
-        referrer,
-      },
       {
         lendingMarket: kaminoMarket.getAddress(),
         payer,
         reserve: reserveAddress,
+        referrer,
         referrerTokenState: referrerTokenStateAddress,
         rent: SYSVAR_RENT_PUBKEY,
         systemProgram: SystemProgram.programId,

package/src/utils/managerTypes.ts

@@ -277,9 +277,7 @@ export const encodeTokenName = (tokenName: string): number[] => {
   for (let i = 0; i < tokenNameEncoded.length; i++) {
     buffer[i] = tokenNameEncoded[i];
   }
-
-  const result = [...buffer];
-  return result;
+  return [...buffer];
 };
 
 function buildReserveConfig(fields: {
@@ -337,13 +335,15 @@ function buildReserveConfig(fields: {
     deleveragingMarginCallPeriodSecs: new BN(0),
     borrowFactorPct: new BN(100),
     elevationGroups: fields.configParams.elevationGroups,
-    deleveragingThresholdSlotsPerBps: new BN(7200),
+    deleveragingThresholdSecsPerBps: new BN(3600),
     disableUsageAsCollOutsideEmode: 0,
     utilizationLimitBlockBorrowingAbove: 0,
     hostFixedInterestRateBps: 0,
+    autodeleverageEnabled: 0,
     borrowLimitOutsideElevationGroup: new BN(0),
     borrowLimitAgainstThisCollateralInElevationGroup: Array(32).fill(new BN(0)),
-    reserved1: Array(2).fill(0),
+    deleveragingBonusIncreaseBpsPerDay: new BN(100),
+    reserved1: Array(1).fill(0),
     reserved2: Array(2).fill(0),
     reserved3: Array(8).fill(0),
   };

package/src/utils/oracle.ts

@@ -1,4 +1,3 @@
-import { parsePriceData } from '@pythnetwork/client';
 import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import { OraclePrices, Scope } from '@kamino-finance/scope-sdk';
@@ -8,6 +7,7 @@ import SwitchboardProgram from '@switchboard-xyz/sbv2-lite';
 import { Reserve } from '../lib';
 import { batchFetch } from '@kamino-finance/kliquidity-sdk';
 import BN from 'bn.js';
+import { PriceUpdateV2 } from '../pyth/accounts';
 
 const SWITCHBOARD_V2_PROGRAM_ID = new PublicKey('SW1TCH7qEPTdLsDHRgPuMQjbQxKdH2aBStViMFnt64f');
 
@@ -166,27 +166,21 @@ export function cacheOrGetPythPrices(
     const result = oracleAccounts.get(oracle);
     if (result) {
       try {
-        const { price, timestamp, emaPrice, previousPrice, previousTimestamp, confidence } = parsePriceData(
-          result.data
-        );
+        const { priceMessage } = PriceUpdateV2.decode(result.data);
+        const { price, exponent, conf: confidence, publishTime: timestamp, emaPrice } = priceMessage;
         if (price) {
-          const px = new Decimal(price);
+          const px = new Decimal(price.toString()).div(10 ** Math.abs(exponent));
           prices.spot = {
             price: px,
-            timestamp,
-            valid: validatePythPx(px, confidence),
-          };
-        } else {
-          prices.spot = {
-            price: new Decimal(previousPrice),
-            timestamp: previousTimestamp,
-            valid: false,
+            timestamp: BigInt(timestamp.toString()),
+            valid: validatePythPx(px, confidence.toNumber()),
           };
         }
         if (emaPrice !== undefined && emaPrice !== null) {
+          const emaPx = new Decimal(emaPrice.toString()).div(10 ** Math.abs(exponent));
           prices.twap = {
-            price: new Decimal(emaPrice.value),
-            timestamp,
+            price: emaPx,
+            timestamp: BigInt(timestamp.toString()),
             valid: true,
           };
         }