@kamino-finance/klend-sdk 6.0.3 → 6.0.5-beta.0

package/src/leverage/types.ts

@@ -1,18 +1,17 @@
-import { Account, Address, IInstruction, Option, Slot, TransactionSigner } from '@solana/kit';
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import { KaminoMarket, KaminoObligation } from '../classes';
 import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
 import { ObligationType, ObligationTypeTag, ScopePriceRefreshConfig } from '../utils';
-import { AddressLookupTable } from '@solana-program/address-lookup-table';
 
 export type SwapQuoteProvider<QuoteResponse> = (
   inputs: SwapInputs,
-  klendAccounts: Array<Address>
+  klendAccounts: Array<PublicKey>
 ) => Promise<SwapQuote<QuoteResponse>>;
 
 export type SwapIxsProvider<QuoteResponse> = (
   inputs: SwapInputs,
-  klendAccounts: Array<Address>,
+  klendAccounts: Array<PublicKey>,
   quote: SwapQuote<QuoteResponse>
 ) => Promise<Array<SwapIxs<QuoteResponse>>>;
 
@@ -22,37 +21,37 @@ export type SwapQuote<QuoteResponse> = {
 };
 
 export type SwapIxs<QuoteResponse> = {
-  preActionIxs: IInstruction[];
-  swapIxs: IInstruction[];
-  lookupTables: Account<AddressLookupTable>[];
+  preActionIxs: TransactionInstruction[];
+  swapIxs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
   quote: SwapQuote<QuoteResponse>;
 };
 
-export type PriceAinBProvider = (mintA: Address, mintB: Address) => Promise<Decimal>;
+export type PriceAinBProvider = (mintA: PublicKey, mintB: PublicKey) => Promise<Decimal>;
 
-export type IsKtokenProvider = (token: Address) => Promise<boolean>;
+export type IsKtokenProvider = (token: PublicKey | string) => Promise<boolean>;
 
 export type FlashLoanInfo = {
-  flashBorrowReserve: Address;
+  flashBorrowReserve: PublicKey;
   flashLoanFee: Decimal;
 };
 
 export type LeverageIxsOutput = {
-  instructions: IInstruction[];
+  instructions: TransactionInstruction[];
   flashLoanInfo: FlashLoanInfo;
 };
 
 export type SwapInputs = {
   inputAmountLamports: Decimal;
   minOutAmountLamports?: Decimal;
-  inputMint: Address;
-  outputMint: Address;
+  inputMint: PublicKey;
+  outputMint: PublicKey;
   amountDebtAtaBalance: Decimal | undefined;
 };
 
 export type BaseLeverageIxsResponse<QuoteResponse> = {
-  ixs: IInstruction[];
-  lookupTables: Account<AddressLookupTable>[];
+  ixs: TransactionInstruction[];
+  lookupTables: AddressLookupTableAccount[];
   swapInputs: SwapInputs;
   flashLoanInfo: FlashLoanInfo;
   quote?: QuoteResponse;
@@ -61,22 +60,22 @@ export type BaseLeverageIxsResponse<QuoteResponse> = {
 export type LeverageInitialInputs<LeverageCalcsResult, QuoteResponse> = {
   calcs: LeverageCalcsResult;
   swapQuote: SwapQuote<QuoteResponse>;
-  currentSlot: Slot;
-  klendAccounts: Array<Address>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
   collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
   strategy: StrategyWithAddress | undefined;
 };
 
 export interface BaseLeverageSwapInputsProps<QuoteResponse> {
-  owner: TransactionSigner;
+  owner: PublicKey;
   kaminoMarket: KaminoMarket;
-  debtTokenMint: Address;
-  collTokenMint: Address;
-  referrer: Option<Address>;
-  currentSlot: Slot;
+  debtTokenMint: PublicKey;
+  collTokenMint: PublicKey;
+  referrer: PublicKey;
+  currentSlot: number;
   slippagePct: Decimal;
-  budgetAndPriorityFeeIxs?: IInstruction[];
+  budgetAndPriorityFeeIxs?: TransactionInstruction[];
   kamino: Kamino | undefined;
   scopeRefreshConfig?: ScopePriceRefreshConfig;
   quoteBufferBps: Decimal;
@@ -92,8 +91,8 @@ export type DepositLeverageIxsResponse<QuoteResponse> = BaseLeverageIxsResponse<
 export type DepositLeverageInitialInputs<QuoteResponse> = {
   calcs: DepositLeverageCalcsResult;
   swapQuote: SwapQuote<QuoteResponse>;
-  currentSlot: Slot;
-  klendAccounts: Array<Address>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
   collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
   strategy: StrategyWithAddress | undefined;
@@ -105,7 +104,7 @@ export interface DepositWithLeverageSwapInputsProps<QuoteResponse> extends BaseL
   depositAmount: Decimal;
   priceDebtToColl: Decimal;
   targetLeverage: Decimal;
-  selectedTokenMint: Address;
+  selectedTokenMint: PublicKey;
   priceAinB: PriceAinBProvider;
   // currently only used to disable requesting elevation group when this value is 0
   // to be implemented properly in the future
@@ -135,8 +134,8 @@ export type WithdrawLeverageIxsResponse<QuoteResponse> = BaseLeverageIxsResponse
 export type WithdrawLeverageInitialInputs<QuoteResponse> = {
   calcs: WithdrawLeverageCalcsResult;
   swapQuote: SwapQuote<QuoteResponse>;
-  currentSlot: Slot;
-  klendAccounts: Array<Address>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
   collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;
   strategy: StrategyWithAddress | undefined;
@@ -149,7 +148,7 @@ export interface WithdrawWithLeverageSwapInputsProps<QuoteResponse> extends Base
   withdrawAmount: Decimal;
   priceCollToDebt: Decimal;
   isClosingPosition: boolean;
-  selectedTokenMint: Address;
+  selectedTokenMint: PublicKey;
 }
 
 export interface WithdrawWithLeverageProps<QuoteResponse> extends WithdrawWithLeverageSwapInputsProps<QuoteResponse> {
@@ -173,8 +172,8 @@ export type AdjustLeverageIxsResponse<QuoteResponse> = BaseLeverageIxsResponse<Q
 export type AdjustLeverageInitialInputs<QuoteResponse> = {
   calcs: AdjustLeverageCalcsResult;
   swapQuote: SwapQuote<QuoteResponse>;
-  currentSlot: Slot;
-  klendAccounts: Array<Address>;
+  currentSlot: number;
+  klendAccounts: Array<PublicKey>;
   isDeposit: boolean;
   collIsKtoken: boolean;
   obligation: KaminoObligation | ObligationType | undefined;

package/src/leverage/utils.ts

@@ -1,13 +1,6 @@
 import { Kamino, StrategyWithAddress } from '@kamino-finance/kliquidity-sdk';
 import { KaminoMarket, KaminoReserve, lamportsToNumberDecimal } from '../classes';
-import {
-  Address,
-  IInstruction,
-  GetAccountInfoApi,
-  Rpc,
-  GetTokenAccountBalanceApi,
-  TransactionSigner,
-} from '@solana/kit';
+import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
 import Decimal from 'decimal.js';
 import { getLookupTableAccounts, getTokenAccountBalanceDecimal } from '../utils';
 import { numberToLamportsDecimal } from '../classes/utils';
@@ -17,12 +10,12 @@ import { PriceAinBProvider, SwapInputs, SwapQuote, SwapIxs, SwapIxsProvider } fr
 export interface KaminoSwapperIxBuilder {
   (
     input: DepositAmountsForSwap,
-    tokenAMint: Address,
-    tokenBMint: Address,
-    owner: TransactionSigner,
+    tokenAMint: PublicKey,
+    tokenBMint: PublicKey,
+    owner: PublicKey,
     slippage: Decimal,
-    allKeys: Address[]
-  ): Promise<[IInstruction[], Address[]]>;
+    allKeys: PublicKey[]
+  ): Promise<[TransactionInstruction[], PublicKey[]]>;
 }
 
 export interface DepositAmountsForSwap {
@@ -35,7 +28,7 @@ export interface DepositAmountsForSwap {
 export async function getTokenToKtokenSwapper<QuoteResponse>(
   kaminoMarket: KaminoMarket,
   kamino: Kamino,
-  depositor: TransactionSigner,
+  depositor: PublicKey,
   slippagePct: Decimal,
   swapper: SwapIxsProvider<QuoteResponse>,
   priceAinB: PriceAinBProvider,
@@ -43,19 +36,19 @@ export async function getTokenToKtokenSwapper<QuoteResponse>(
 ): Promise<SwapIxsProvider<QuoteResponse>> {
   return async (
     inputs: SwapInputs,
-    klendAccounts: Array<Address>,
+    klendAccounts: Array<PublicKey>,
     quote: SwapQuote<QuoteResponse>
   ): Promise<Array<SwapIxs<QuoteResponse>>> => {
     const slippageBps = new Decimal(slippagePct).mul('100');
     const mintInDecimals = kaminoMarket.getExistingReserveByMint(inputs.inputMint).getMintDecimals();
     const amountIn = lamportsToNumberDecimal(inputs.inputAmountLamports, mintInDecimals);
-    console.debug('Depositing token', inputs.inputMint, ' for ', inputs.outputMint, 'ktoken');
+    console.debug('Depositing token', inputs.inputMint.toString(), ' for ', inputs.outputMint.toString(), 'ktoken');
     if (inputs.amountDebtAtaBalance === undefined) {
       throw Error('Amount in debt ATA balance is undefined for leverage ktoken deposit');
     }
 
     const ixWithLookup = (await getKtokenDepositIxs(
-      kaminoMarket.getRpc(),
+      kaminoMarket.getConnection(),
       kamino,
       depositor,
       inputs.inputMint,
@@ -70,7 +63,7 @@ export async function getTokenToKtokenSwapper<QuoteResponse>(
       quote
     ))!;
 
-    const luts = await getLookupTableAccounts(kaminoMarket.getRpc(), ixWithLookup.lookupTablesAddresses);
+    const luts = await getLookupTableAccounts(kaminoMarket.getConnection(), ixWithLookup.lookupTablesAddresses);
 
     return [
       {
@@ -88,18 +81,18 @@ export async function getTokenToKtokenSwapper<QuoteResponse>(
 }
 
 export async function getKtokenDepositIxs<QuoteResponse>(
-  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
+  connection: Connection,
   kamino: Kamino,
-  depositor: TransactionSigner,
-  depositTokenMint: Address,
-  ktokenMint: Address,
+  depositor: PublicKey,
+  depositTokenMint: PublicKey,
+  ktokenMint: PublicKey,
   amountToDeposit: Decimal,
   slippageBps: Decimal,
   amountExpectedDepositAtaBalance: Decimal,
   swapper: SwapIxsProvider<QuoteResponse>,
   priceAinB: PriceAinBProvider,
   includeAtaIxs: boolean = true,
-  klendAccounts: Array<Address>,
+  klendAccounts: Array<PublicKey>,
   quote: SwapQuote<QuoteResponse>
 ) {
   const kaminoStrategy = await kamino.getStrategyByKTokenMint(ktokenMint);
@@ -107,8 +100,8 @@ export async function getKtokenDepositIxs<QuoteResponse>(
   const tokenBMint = kaminoStrategy?.strategy.tokenBMint!;
   const priceAinBDecimal = await priceAinB(tokenAMint, tokenBMint);
 
-  if (tokenAMint === depositTokenMint) {
-    const bBalance = await getTokenAccountBalanceDecimal(rpc, tokenBMint, depositor.address);
+  if (tokenAMint.equals(depositTokenMint)) {
+    const bBalance = await getTokenAccountBalanceDecimal(connection, tokenBMint, depositor);
     const tokensBalances = { a: amountExpectedDepositAtaBalance, b: bBalance };
     console.log('amountToDeposit', amountToDeposit);
     return await kamino.singleSidedDepositTokenA(
@@ -122,8 +115,8 @@ export async function getKtokenDepositIxs<QuoteResponse>(
       priceAinBDecimal,
       includeAtaIxs
     );
-  } else if (tokenBMint === depositTokenMint) {
-    const aBalance = await getTokenAccountBalanceDecimal(rpc, tokenAMint, depositor.address);
+  } else if (tokenBMint.equals(depositTokenMint)) {
+    const aBalance = await getTokenAccountBalanceDecimal(connection, tokenAMint, depositor);
     const tokensBalances = { a: aBalance, b: amountExpectedDepositAtaBalance };
     return await kamino.singleSidedDepositTokenB(
       kaminoStrategy!,
@@ -144,10 +137,10 @@ export async function getKtokenDepositIxs<QuoteResponse>(
 export async function getKtokenToTokenSwapper<QuoteResponse>(
   kaminoMarket: KaminoMarket,
   kamino: Kamino,
-  depositor: TransactionSigner,
+  depositor: PublicKey,
   swapper: SwapIxsProvider<QuoteResponse>
 ): Promise<SwapIxsProvider<QuoteResponse>> {
-  return async (inputs: SwapInputs, klendAccounts: Array<Address>, quote: SwapQuote<QuoteResponse>) => {
+  return async (inputs: SwapInputs, klendAccounts: Array<PublicKey>, quote: SwapQuote<QuoteResponse>) => {
     const amountInDecimals = kaminoMarket.getExistingReserveByMint(inputs.inputMint).getMintDecimals();
     const amountToWithdraw = lamportsToNumberDecimal(inputs.inputAmountLamports, amountInDecimals);
     const kaminoStrategy = await kamino.getStrategyByKTokenMint(inputs.inputMint);
@@ -162,7 +155,7 @@ export async function getKtokenToTokenSwapper<QuoteResponse>(
       amountToWithdraw
     );
 
-    if (inputs.outputMint === kaminoStrategy!.strategy.tokenAMint!) {
+    if (inputs.outputMint.equals(kaminoStrategy!.strategy.tokenAMint!)) {
       const swapArray = await swapper(
         {
           inputAmountLamports: estimatedBOut,
@@ -184,7 +177,7 @@ export async function getKtokenToTokenSwapper<QuoteResponse>(
           quote: swap.quote,
         },
       ];
-    } else if (inputs.outputMint === kaminoStrategy!.strategy.tokenBMint) {
+    } else if (inputs.outputMint.equals(kaminoStrategy!.strategy.tokenBMint!)) {
       const swapArray = await swapper(
         {
           inputAmountLamports: estimatedAOut,
@@ -214,7 +207,7 @@ export async function getKtokenToTokenSwapper<QuoteResponse>(
 
 export async function getKtokenWithdrawIxs(
   kamino: Kamino,
-  withdrawer: TransactionSigner,
+  withdrawer: PublicKey,
   kaminoStrategy: StrategyWithAddress,
   amountToWithdraw: Decimal
 ) {
@@ -276,17 +269,17 @@ export async function getKtokenWithdrawEstimatesAndPrice(
 
 export function swapProviderToKaminoSwapProvider<QuoteResponse>(
   swapper: SwapIxsProvider<QuoteResponse>,
-  klendAccounts: Array<Address>,
+  klendAccounts: Array<PublicKey>,
   swapQuote: SwapQuote<QuoteResponse>
 ): KaminoSwapperIxBuilder {
   return async (
     input: DepositAmountsForSwap,
-    tokenAMint: Address,
-    tokenBMint: Address,
-    _owner: TransactionSigner,
+    tokenAMint: PublicKey,
+    tokenBMint: PublicKey,
+    _owner: PublicKey,
     _slippage: Decimal,
-    _allKeys: Address[]
-  ): Promise<[IInstruction[], Address[]]> => {
+    _allKeys: PublicKey[]
+  ): Promise<[TransactionInstruction[], PublicKey[]]> => {
     if (input.tokenBToSwapAmount.lt(0)) {
       const swapperIxsArray = await swapper(
         {
@@ -300,7 +293,7 @@ export function swapProviderToKaminoSwapProvider<QuoteResponse>(
       );
       // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
       const swapperIxs = swapperIxsArray[0];
-      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.address)];
+      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.key)];
     } else if (input.tokenAToSwapAmount.lt(0)) {
       const swapperIxsArray = await swapper(
         {
@@ -314,7 +307,7 @@ export function swapProviderToKaminoSwapProvider<QuoteResponse>(
       );
       // TODO: Ktoken only supports one swap at a time for now (to be updated if we enable ktokens)
       const swapperIxs = swapperIxsArray[0];
-      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.address)];
+      return [swapperIxs.swapIxs, swapperIxs.lookupTables.map((lt) => lt.key)];
     } else {
       throw Error('Nothing to swap');
     }
@@ -322,13 +315,13 @@ export function swapProviderToKaminoSwapProvider<QuoteResponse>(
 }
 
 export const getExpectedTokenBalanceAfterBorrow = async (
-  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
-  mint: Address,
-  owner: Address,
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey,
   amountToBorrowLamports: Decimal,
   amountToBorrowMintDecimals: number
-): Promise<Decimal> => {
-  const initialUserTokenABalance = await getTokenAccountBalanceDecimal(rpc, mint, owner);
+) => {
+  const initialUserTokenABalance = await getTokenAccountBalanceDecimal(connection, mint, owner);
 
   return initialUserTokenABalance
     .add(lamportsToNumberDecimal(amountToBorrowLamports, amountToBorrowMintDecimals))

package/src/lib.ts

@@ -1,13 +1,13 @@
-export * from './@codegen/klend/instructions';
-export * from './@codegen/klend/accounts';
-export * from './@codegen/klend/programId';
-export * from './@codegen/klend/zero_padding';
+export * from './idl_codegen/instructions';
+export * from './idl_codegen/accounts';
+export * from './idl_codegen/programId';
+export * from './idl_codegen/zero_padding';
 
-export * from './@codegen/kvault/instructions';
-// only export vault state, do not export Reserve as it's the same one in main klend /@codegen/klend/accounts
-export * from './@codegen/kvault/accounts/VaultState';
-export * from './@codegen/kvault/types';
-export { PROGRAM_ID as KVAULTS_PROGRAM_ID } from './@codegen/kvault/programId';
+export * from './idl_codegen_kamino_vault/instructions';
+// only export vault state, do not export Reserve as it's the same one in main klend /idl_codegen/accounts
+export * from './idl_codegen_kamino_vault/accounts/VaultState';
+export * from './idl_codegen_kamino_vault/types';
+export { KVAULTS_PROGRAM_ID, setKVaultsProgramId } from './idl_codegen_kamino_vault/programId';
 
 export * from './classes';
 export * from './utils';

package/src/obligation_orders/price_based.ts

@@ -6,7 +6,8 @@ import {
   ObligationOrderAtIndex,
   OrderCondition,
 } from '../classes/obligationOrder';
-import { Address } from '@solana/kit';
+import { PublicKeySet } from '../utils';
+import { PublicKey } from '@solana/web3.js';
 import { checkThat, getSingleElement } from '../utils/validations';
 import { OrderContext, OrderSpecification, OrderType } from './common';
 import { createConditionBasedOrder, readTriggerBasedOrder, toOrderIndex } from './internal';
@@ -67,7 +68,7 @@ export type PriceBasedOrderContext = OrderContext & {
 /**
  * A convenient multi-way of specifying a token.
  */
-export type SymbolOrMintAddress = string | Address;
+export type SymbolOrMintAddress = string | PublicKey;
 
 /**
  * A high-level specification of a price-based order.
@@ -226,15 +227,15 @@ function resolvePositionType(context: PriceBasedOrderContext): PositionType {
   const collateralReserveAddress = getSingleElement(context.kaminoObligation.deposits.keys(), 'deposit');
   const debtReserveAddress = getSingleElement(context.kaminoObligation.borrows.keys(), 'borrow');
   const stablecoinReserveAddresses = collectReserveAddresses(context.kaminoMarket, context.stablecoins);
-  if (stablecoinReserveAddresses.has(collateralReserveAddress)) {
+  if (stablecoinReserveAddresses.contains(collateralReserveAddress)) {
     checkThat(
-      !stablecoinReserveAddresses.has(debtReserveAddress),
+      !stablecoinReserveAddresses.contains(debtReserveAddress),
       'cannot resolve long vs short position from all-stablecoins obligation'
     );
     return PositionType.Short;
   } else {
     checkThat(
-      stablecoinReserveAddresses.has(debtReserveAddress),
+      stablecoinReserveAddresses.contains(debtReserveAddress),
       'cannot resolve long vs short position from no-stablecoins obligation'
     );
     return PositionType.Long;
@@ -244,8 +245,8 @@ function resolvePositionType(context: PriceBasedOrderContext): PositionType {
 function collectReserveAddresses(
   kaminoMarket: KaminoMarket,
   symbolOrMintAddresses: SymbolOrMintAddress[]
-): Set<Address> {
-  return new Set<Address>(
+): PublicKeySet<PublicKey> {
+  return new PublicKeySet(
     symbolOrMintAddresses.map((symbolOrMintAddress) =>
       typeof symbolOrMintAddress === 'string'
         ? kaminoMarket.getExistingReserveBySymbol(symbolOrMintAddress).address

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 type { 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);
+  }
+}