@exponent-labs/exponent-types 0.1.7 → 0.9.0

package/build/vault.d.ts

@@ -1,7 +1,8 @@
-import { BN, web3 } from "@coral-xyz/anchor";
 import { IFlavorStateJson, Flavor } from "./flavor";
 import { CpiAccountsRaw, CpiAccountsRawJson } from "./cpi";
 import { AnchorizedPNum, AnchorizedPNumJson } from "./common";
+import { PublicKey } from "@solana/web3.js";
+import BN from 'bn.js';
 export type VaultJson = {
     /** When does the vault start, as a UNIX timestamp */
     startTs: number;
@@ -55,6 +56,7 @@ export type VaultJson = {
     flavor: IFlavorStateJson;
     emissions: VaultEmissionJson[];
     maxPySupply: string;
+    state: VaultStateJson;
 };
 export interface VaultState {
     /** supply of PT */
@@ -65,26 +67,26 @@ export interface VaultState {
     /** For how long is the vault active */
     durationSeconds: number;
     /** Vault signer for token accounts, mints, SY position etc */
-    authority: web3.PublicKey;
-    addressLookupTable: web3.PublicKey;
+    authority: PublicKey;
+    addressLookupTable: PublicKey;
     lastSeenSyExchangeRate: number;
     allTimeHighSyExchangeRate: number;
     /** Vault-owned account for passing SY between SY program and user */
-    escrowSy: web3.PublicKey;
+    escrowSy: PublicKey;
     /** Escrow account for holding deposited YT */
-    escrowYt: web3.PublicKey;
+    escrowYt: PublicKey;
     /** Key to SY Program */
-    syProgram: web3.PublicKey;
+    syProgram: PublicKey;
     syPosition: SyPosition;
     cpiAccounts: CpiAccountsRaw;
-    mintPt: web3.PublicKey;
+    mintPt: PublicKey;
     status: number;
     minOperationSizeStrip: bigint;
     minOperationSizeMerge: bigint;
-    mintYt: web3.PublicKey;
-    mintSy: web3.PublicKey;
-    yieldPositonAddress: web3.PublicKey;
-    treasurySyTokenAccount: web3.PublicKey;
+    mintYt: PublicKey;
+    mintSy: PublicKey;
+    yieldPositonAddress: PublicKey;
+    treasurySyTokenAccount: PublicKey;
     interestBpsFee: number;
     totalSyInEscrow: bigint;
     flavor: Flavor;
@@ -92,6 +94,42 @@ export interface VaultState {
     emissions: VaultEmission[];
     maxPySupply: bigint;
 }
+export interface VaultStateJson {
+    /** supply of PT */
+    ptSupply: string;
+    syForPt: string;
+    /** When does the vault start, as a UNIX timestamp */
+    startTs: number;
+    /** For how long is the vault active */
+    durationSeconds: number;
+    /** Vault signer for token accounts, mints, SY position etc */
+    authority: string;
+    addressLookupTable: string;
+    lastSeenSyExchangeRate: number;
+    allTimeHighSyExchangeRate: number;
+    /** Vault-owned account for passing SY between SY program and user */
+    escrowSy: string;
+    /** Escrow account for holding deposited YT */
+    escrowYt: string;
+    /** Key to SY Program */
+    syProgram: string;
+    syPosition: SyPositionJson;
+    cpiAccounts: CpiAccountsRawJson;
+    mintPt: string;
+    status: number;
+    minOperationSizeStrip: string;
+    minOperationSizeMerge: string;
+    mintYt: string;
+    mintSy: string;
+    yieldPositonAddress: string;
+    treasurySyTokenAccount: string;
+    interestBpsFee: number;
+    totalSyInEscrow: string;
+    flavor: IFlavorStateJson;
+    finalSyExchangeRate: number;
+    emissions: VaultEmissionJson[];
+    maxPySupply: string;
+}
 export interface SyPositionJson {
     balanceSy: string;
     owner: string;
@@ -103,22 +141,22 @@ export interface SyPositionJson {
 }
 export interface SyPosition {
     balanceSy: bigint;
-    owner: web3.PublicKey;
+    owner: PublicKey;
     emissions: {
         /** Last seen index for SY-to-emission exchange rate */
         lastSeenIndex: number;
         /** mint of emission token */
-        mint: web3.PublicKey;
+        mint: PublicKey;
         /** How many emissions are staged to claim */
         staged: bigint;
     }[];
 }
 export interface VaultEmission {
-    tokenAccount: web3.PublicKey;
+    tokenAccount: PublicKey;
     initialIndex: AnchorizedPNum;
     lastSeenIndex: AnchorizedPNum;
     finalIndex: AnchorizedPNum;
-    treasuryTokenAccount: web3.PublicKey;
+    treasuryTokenAccount: PublicKey;
     feeBps: number;
     treasuryEmission: BN;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exponent-labs/exponent-types",
-  "version": "0.1.7",
+  "version": "0.9.0",
   "main": "build/index.js",
   "types": "build/index.d.ts",
   "license": "AGPL-3.0",
@@ -8,7 +8,9 @@
     "build": "tsc --build"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "0.31.0"
+    "@solana/web3.js": "1.98.4",
+    "@solana/spl-stake-pool": "1.1.8",
+    "bn.js": "5.2.2"
   },
   "devDependencies": {
     "typescript": "5.4.5"

package/src/common.ts

@@ -1,23 +1,24 @@
-import { BN, web3 } from "@coral-xyz/anchor"
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
 
 export interface SyEmissionRaw {
-  mint: web3.PublicKey
+  mint: PublicKey
   index: AnchorizedPNum
   lastSeenTotalAccruedEmissions: BN
   totalClaimedEmissions: BN
-  tokenProgram: web3.PublicKey
-  escrowAccount: web3.PublicKey
+  tokenProgram: PublicKey
+  escrowAccount: PublicKey
   treasuryEmission: BN
   lastSeenIndex: AnchorizedPNum
 }
 
 export interface SyEmissionRaw2 {
-  mint: web3.PublicKey
+  mint: PublicKey
   index: AnchorizedPNum
   last_seen_total_accrued_emissions: BN
   total_claimed_emissions: BN
-  token_program: web3.PublicKey
-  escrow_account: web3.PublicKey
+  token_program: PublicKey
+  escrow_account: PublicKey
   treasury_emission: BN
   last_seen_index: AnchorizedPNum
 }
@@ -34,4 +35,4 @@ export interface SyEmissionJson {
 }
 
 export type AnchorizedPNum = { 0: BN[] }
-export type AnchorizedPNumJson = { 0: string[] }
+export type AnchorizedPNumJson = { 0: string[] }

package/src/cpi.ts

@@ -1,7 +1,7 @@
-import { web3 } from "@coral-xyz/anchor"
+import { PublicKey } from "@solana/web3.js"
 
 export interface AccountInfo {
-  pubkey: web3.PublicKey
+  pubkey: PublicKey
   isSigner: boolean
   isWritable: boolean
 }
@@ -15,6 +15,15 @@ export interface CpiMeta<T> {
   getPositionState: T[]
 }
 
+/** Generic container for ExponentCore CPI account lists */
+export interface ExponentCoreCpiMeta<T> {
+  depositYt: T[]
+  withdrawYt: T[]
+  stripSy: T[]
+  mergeSy: T[]
+  collectInterest: T[]
+}
+
 /** The on-chain storage for CPI accounts, which references an ALT */
 export interface CpiAccountIndex {
   /** Index in the Address Lookup Table */
@@ -26,9 +35,15 @@ export interface CpiAccountIndex {
 /**  Raw account infos for CPI that include the Pubkey */
 export type CpiAccountsRaw = CpiMeta<AccountInfo>
 
+/**  Raw account infos for CPI that include the Pubkey */
+export type ExponentCoreCpiAccountsRaw = ExponentCoreCpiMeta<AccountInfo>
+
 /** This account is stored in state on the vault/market to track indexes in the ALT */
 export type CpiAccountIndexes = CpiMeta<CpiAccountIndex>
 
+/** This account is stored in state on the vault/market to track indexes in the ALT */
+export type ExponentCoreCpiIndexes = ExponentCoreCpiMeta<CpiAccountIndex>
+
 export interface CpiAccountsRawJson {
   getSyState: AccountInfoJson[]
   withdrawSy: AccountInfoJson[]
@@ -37,6 +52,14 @@ export interface CpiAccountsRawJson {
   getPositionState: AccountInfoJson[]
 }
 
+export interface ExponentCoreCpiAccountsRawJson {
+  depositYt: AccountInfoJson[]
+  withdrawYt: AccountInfoJson[]
+  stripSy: AccountInfoJson[]
+  mergeSy: AccountInfoJson[]
+  collectInterest: AccountInfoJson[]
+}
+
 export type AccountInfoJson = {
   pubkey: string
   isSigner: boolean
@@ -45,7 +68,7 @@ export type AccountInfoJson = {
 
 export function deserializeCpiAccountsRaw(serialized: CpiAccountsRawJson): CpiAccountsRaw {
   const deserializeAccountInfo = (accountInfo: AccountInfoJson): AccountInfo => ({
-    pubkey: new web3.PublicKey(accountInfo.pubkey),
+    pubkey: new PublicKey(accountInfo.pubkey),
     isSigner: accountInfo.isSigner,
     isWritable: accountInfo.isWritable,
   })
@@ -73,3 +96,20 @@ export function serializeCpiAccountsRaw(cpiAccounts: CpiAccountsRaw): CpiAccount
     getPositionState: cpiAccounts.getPositionState.map(serializeAccountInfo),
   }
 }
+
+/** MarketThree/CLMM only uses a subset of ExponentCore CPI accounts (strip and merge) */
+export interface MarketCpiCoreMeta<T> {
+  stripSy: T[]
+  mergeSy: T[]
+}
+
+export interface MarketCpiCoreAccountsRawJson {
+  stripSy: AccountInfoJson[]
+  mergeSy: AccountInfoJson[]
+}
+
+/** Type alias for MarketThree's CPI core accounts with pubkeys */
+export type MarketCpiCoreAccountsRaw = MarketCpiCoreMeta<AccountInfo>
+
+/** Type alias for MarketThree's CPI core accounts stored in state */
+export type MarketCpiCoreIndexes = MarketCpiCoreMeta<CpiAccountIndex>

package/src/flavor.ts

@@ -1,41 +1,40 @@
-import { web3 } from "@coral-xyz/anchor"
 import { MfiSyStateJson, MfiSyState } from "./marginfi"
 import { KaminoSyState, KaminoSyStateJson } from "./kamino"
 import { JitoRestakingSyState, JitoRestakingSyStateJson } from "./jito-restaking"
 import { AnchorizedPNum } from "./common"
 import { PerenaSyState, PerenaSyStateJson } from "./perena"
 import { GenericSyState, GenericSyStateJson } from "./generic"
-
+import {PublicKey, TransactionInstruction} from "@solana/web3.js"
 export type FlavorDiscriminator = "marginfi" | "kamino" | "jitoRestaking" | "perena" | "generic"
 
 export type MintSyArgs = {
   amountBase: string
-  depositor: web3.PublicKey
-  depositorBaseTokenAccount: web3.PublicKey
-  depositorSyTokenAccount: web3.PublicKey
+  depositor: PublicKey
+  depositorBaseTokenAccount: PublicKey
+  depositorSyTokenAccount: PublicKey
 }
 
 export type RedeemSyArgs = {
   amountSy: string
-  redeemer: web3.PublicKey
-  redeemerBaseTokenAccount: web3.PublicKey
-  redeemerSyTokenAccount: web3.PublicKey
+  redeemer: PublicKey
+  redeemerBaseTokenAccount: PublicKey
+  redeemerSyTokenAccount: PublicKey
 }
 
 export type InterfaceInstructionArgs = {
-  signer: web3.PublicKey
+  signer: PublicKey
   amountBase: string
 }
 
 type BaseFlavorState = {
   flavor: FlavorDiscriminator
   currentSyExchangeRate: number
-  mintBase: web3.PublicKey
-  baseTokenProgram: web3.PublicKey
+  mintBase: PublicKey
+  baseTokenProgram: PublicKey
   emissions: {
     exchangeRate: AnchorizedPNum
-    mint: web3.PublicKey
-    tokenProgram: web3.PublicKey
+    mint: PublicKey
+    tokenProgram: PublicKey
   }[]
 }
 
@@ -52,12 +51,12 @@ type BaseFlavorStateJson = {
 }
 
 interface BaseFlavorTrait {
-  ixMintSy: (args: MintSyArgs) => Promise<web3.TransactionInstruction>
-  ixRedeemSy: (args: RedeemSyArgs) => Promise<web3.TransactionInstruction>
-  preIxs: (args: { signer: web3.PublicKey }) => Promise<web3.TransactionInstruction[]>
-  postIxs: (args: { signer: web3.PublicKey }) => Promise<web3.TransactionInstruction[]>
-  preMintSyIx?: (args: InterfaceInstructionArgs) => Promise<web3.TransactionInstruction[]>
-  postRedeemSyIx?: (args: InterfaceInstructionArgs) => Promise<web3.TransactionInstruction[]>
+  ixMintSy: (args: MintSyArgs) => Promise<TransactionInstruction>
+  ixRedeemSy: (args: RedeemSyArgs) => Promise<TransactionInstruction>
+  preIxs: (args: { signer: PublicKey }) => Promise<TransactionInstruction[]>
+  postIxs: (args: { signer: PublicKey }) => Promise<TransactionInstruction[]>
+  preMintSyIx?: (args: InterfaceInstructionArgs) => Promise<TransactionInstruction[]>
+  postRedeemSyIx?: (args: InterfaceInstructionArgs) => Promise<TransactionInstruction[]>
 }
 
 export interface FlavorKaminoState extends BaseFlavorState {
@@ -67,9 +66,9 @@ export interface FlavorKaminoState extends BaseFlavorState {
 
 export interface FlavorMarginfiState extends BaseFlavorState {
   flavor: "marginfi"
-  bank: web3.PublicKey
-  emissionMint?: web3.PublicKey
-  emissionTokenProgram?: web3.PublicKey
+  bank: PublicKey
+  emissionMint?: PublicKey
+  emissionTokenProgram?: PublicKey
   mfiSyState: MfiSyState
 }
 

package/src/generic.ts

@@ -1,7 +1,7 @@
-import { BN, web3 } from "@coral-xyz/anchor"
-
+import { PublicKey } from "@solana/web3.js"
 import { AnchorizedPNum, SyEmissionJson, SyEmissionRaw } from "./common"
-
+import { StakePoolAccount } from "@solana/spl-stake-pool"
+import BN from 'bn.js'
 export type InterfaceTypeGeneric =
   | {
       pyth: {
@@ -58,6 +58,19 @@ export type InterfaceTypeGeneric =
         padding: number[]
       }
     }
+  | {
+      reflect: {
+        padding: number[]
+      }
+    }
+  | {
+      ore: Record<string, never>
+    }
+  | {
+      chainlink: {
+        padding: number[]
+      }
+    }
 export type InterfaceTypeGenericJson =
   | {
       pyth: {
@@ -114,29 +127,51 @@ export type InterfaceTypeGenericJson =
         padding: number[]
       }
     }
+  | {
+      reflect: {
+        padding: number[]
+      }
+    }
+  | {
+      ore: Record<string, never>
+    }
+  | {
+      chainlink: {
+        padding: number[]
+      }
+    }
 /** Additional data that different interface types may need */
 export interface AdditionalDataGeneric {
   fragmetricData?: {
-    receiptTokenMint: web3.PublicKey
-    wrappedTokenMint: web3.PublicKey
+    receiptTokenMint: PublicKey
+    wrappedTokenMint: PublicKey
   }
   jupiterLendData?: {
-    baseTokenMint: web3.PublicKey
-    tokenReservesLiquidity: web3.PublicKey
-    lendingSupplyPosition: web3.PublicKey
-    rewardsRateModel: web3.PublicKey
-    rateModel: web3.PublicKey
+    baseTokenMint: PublicKey
+    tokenReservesLiquidity: PublicKey
+    lendingSupplyPosition: PublicKey
+    rewardsRateModel: PublicKey
+    rateModel: PublicKey
   }
   kaminoVaultData?: {
-    vault: web3.PublicKey
+    vault: PublicKey
     reserves: {
-      reserveAddress: web3.PublicKey
-      marketAddress: web3.PublicKey
+      reserveAddress: PublicKey
+      marketAddress: PublicKey
     }[]
-    tokenVault: web3.PublicKey
-    tokenMint: web3.PublicKey
-    baseVaultAuthority: web3.PublicKey
-    sharesMint: web3.PublicKey
+    tokenVault: PublicKey
+    tokenMint: PublicKey
+    baseVaultAuthority: PublicKey
+    sharesMint: PublicKey
+  }
+  splStakePoolData?: {
+    stakePoolAccount?: StakePoolAccount // Optional because it is expensive to serialize / not always needed on clients
+    stakePoolAddress: PublicKey
+    stakePoolProgramId: PublicKey // Dynamic program ID from account owner
+    validatorList: PublicKey
+    reserveStake: PublicKey
+    managerFeeAccount: PublicKey
+    poolMint: PublicKey
   }
   // Add other interface-specific data here as needed
   // meteoraData?: { ... }
@@ -153,6 +188,28 @@ export interface AdditionalDataGenericJson {
   jupiterLendData?: {
     baseTokenMint: string
     tokenReservesLiquidity: string
+    lendingSupplyPosition: string
+    rewardsRateModel: string
+    rateModel: string
+  }
+  kaminoVaultData?: {
+    vault: string
+    reserves: {
+      reserveAddress: string
+      marketAddress: string
+    }[]
+    tokenVault: string
+    tokenMint: string
+    baseVaultAuthority: string
+    sharesMint: string
+  }
+  splStakePoolData?: {
+    stakePoolAddress: string
+    stakePoolProgramId: string
+    validatorList: string
+    reserveStake: string
+    managerFeeAccount: string
+    poolMint: string
   }
   // Add other interface-specific data here as needed
   // meteoraData?: { ... }
@@ -163,7 +220,15 @@ export interface AdditionalDataGenericJson {
 export interface Hook {
   enabled: boolean
   interfaceEmissionsAccountsUntil: number
-  programId: web3.PublicKey
+  programId: PublicKey
+  preMintHookDiscriminator: number[]
+  postRedeemHookDiscriminator: number[]
+}
+
+export interface HookJson {
+  enabled: boolean
+  interfaceEmissionsAccountsUntil: number
+  programId: string
   preMintHookDiscriminator: number[]
   postRedeemHookDiscriminator: number[]
 }
@@ -173,13 +238,13 @@ export interface HookRaw {
   interfaceEmissionsAccountsUntil: number
   preMintHookDiscriminator: Buffer
   postRedeemHookDiscriminator: Buffer
-  programId: web3.PublicKey
+  programId: PublicKey
 }
 
 export interface GenericSyState {
-  selfAddress: web3.PublicKey
+  selfAddress: PublicKey
   account: GenericSyMetaAccount
-  tokenProgramBase: web3.PublicKey
+  tokenProgramBase: PublicKey
   syRate: number
   additionalData?: AdditionalDataGeneric
 }
@@ -206,16 +271,16 @@ export interface GenericSyMetaAccountJson {
   maxSySupply: string
   minMintSize: string
   minRedeemSize: string
-  hook: HookRaw
+  hook: HookJson
   emissions: SyEmissionJson[]
   index: number
 }
 
 export interface GenericSyMetaAccount {
-  mintSy: web3.PublicKey
-  yieldBearingMint: web3.PublicKey
-  tokenSyEscrow: web3.PublicKey
-  interfaceAccounts: web3.PublicKey[]
+  mintSy: PublicKey
+  yieldBearingMint: PublicKey
+  tokenSyEscrow: PublicKey
+  interfaceAccounts: PublicKey[]
   interfaceType: InterfaceTypeGeneric
   maxSySupply: BN
   minMintSize: BN
@@ -226,15 +291,15 @@ export interface GenericSyMetaAccount {
 }
 
 export interface GenericSyMetaAccountRaw {
-  mintSy: web3.PublicKey
-  yieldBearingMint: web3.PublicKey
-  tokenSyEscrow: web3.PublicKey
+  mintSy: PublicKey
+  yieldBearingMint: PublicKey
+  tokenSyEscrow: PublicKey
   maxSySupply: BN
   minMintSize: BN
   minRedeemSize: BN
   selfAddressBump: number[]
   emissions: SyEmissionRaw[]
-  interfaceAccounts: web3.PublicKey[]
+  interfaceAccounts: PublicKey[]
   interfaceType: InterfaceTypeGeneric
   index: AnchorizedPNum
   hook: HookRaw
@@ -351,6 +416,28 @@ export function fromInterfaceTypeGenericJson(json: InterfaceTypeGenericJson): In
   return json as InterfaceTypeGeneric
 }
 
+/** Convert Hook to HookJson */
+export function toHookJson(hook: Hook): HookJson {
+  return {
+    enabled: hook.enabled,
+    interfaceEmissionsAccountsUntil: hook.interfaceEmissionsAccountsUntil,
+    programId: hook.programId.toString(),
+    preMintHookDiscriminator: hook.preMintHookDiscriminator,
+    postRedeemHookDiscriminator: hook.postRedeemHookDiscriminator,
+  }
+}
+
+/** Convert HookJson to Hook */
+export function fromHookJson(json: HookJson): Hook {
+  return {
+    enabled: json.enabled,
+    interfaceEmissionsAccountsUntil: json.interfaceEmissionsAccountsUntil,
+    programId: new PublicKey(json.programId),
+    preMintHookDiscriminator: json.preMintHookDiscriminator,
+    postRedeemHookDiscriminator: json.postRedeemHookDiscriminator,
+  }
+}
+
 /** Convert AdditionalDataGeneric to AdditionalDataGenericJson */
 export function toAdditionalDataGenericJson(additionalData: AdditionalDataGeneric): AdditionalDataGenericJson {
   const result: AdditionalDataGenericJson = {}
@@ -362,6 +449,41 @@ export function toAdditionalDataGenericJson(additionalData: AdditionalDataGeneri
     }
   }
 
+  if (additionalData.jupiterLendData) {
+    result.jupiterLendData = {
+      baseTokenMint: additionalData.jupiterLendData.baseTokenMint.toString(),
+      tokenReservesLiquidity: additionalData.jupiterLendData.tokenReservesLiquidity.toString(),
+      lendingSupplyPosition: additionalData.jupiterLendData.lendingSupplyPosition.toString(),
+      rewardsRateModel: additionalData.jupiterLendData.rewardsRateModel.toString(),
+      rateModel: additionalData.jupiterLendData.rateModel.toString(),
+    }
+  }
+
+  if (additionalData.kaminoVaultData) {
+    result.kaminoVaultData = {
+      vault: additionalData.kaminoVaultData.vault.toString(),
+      reserves: additionalData.kaminoVaultData.reserves.map((r) => ({
+        reserveAddress: r.reserveAddress.toString(),
+        marketAddress: r.marketAddress.toString(),
+      })),
+      tokenVault: additionalData.kaminoVaultData.tokenVault.toString(),
+      tokenMint: additionalData.kaminoVaultData.tokenMint.toString(),
+      baseVaultAuthority: additionalData.kaminoVaultData.baseVaultAuthority.toString(),
+      sharesMint: additionalData.kaminoVaultData.sharesMint.toString(),
+    }
+  }
+
+  if (additionalData.splStakePoolData) {
+    result.splStakePoolData = {
+      stakePoolAddress: additionalData.splStakePoolData.stakePoolAddress.toString(),
+      stakePoolProgramId: additionalData.splStakePoolData.stakePoolProgramId.toString(),
+      validatorList: additionalData.splStakePoolData.validatorList.toString(),
+      reserveStake: additionalData.splStakePoolData.reserveStake.toString(),
+      managerFeeAccount: additionalData.splStakePoolData.managerFeeAccount.toString(),
+      poolMint: additionalData.splStakePoolData.poolMint.toString(),
+    }
+  }
+
   return result
 }
 
@@ -371,8 +493,43 @@ export function fromAdditionalDataGenericJson(json: AdditionalDataGenericJson):
 
   if (json.fragmetricData) {
     result.fragmetricData = {
-      receiptTokenMint: new web3.PublicKey(json.fragmetricData.receiptTokenMint),
-      wrappedTokenMint: new web3.PublicKey(json.fragmetricData.wrappedTokenMint),
+      receiptTokenMint: new PublicKey(json.fragmetricData.receiptTokenMint),
+      wrappedTokenMint: new PublicKey(json.fragmetricData.wrappedTokenMint),
+    }
+  }
+
+  if (json.jupiterLendData) {
+    result.jupiterLendData = {
+      baseTokenMint: new PublicKey(json.jupiterLendData.baseTokenMint),
+      tokenReservesLiquidity: new PublicKey(json.jupiterLendData.tokenReservesLiquidity),
+      lendingSupplyPosition: new PublicKey(json.jupiterLendData.lendingSupplyPosition),
+      rewardsRateModel: new PublicKey(json.jupiterLendData.rewardsRateModel),
+      rateModel: new PublicKey(json.jupiterLendData.rateModel),
+    }
+  }
+
+  if (json.kaminoVaultData) {
+    result.kaminoVaultData = {
+      vault: new PublicKey(json.kaminoVaultData.vault),
+      reserves: json.kaminoVaultData.reserves.map((r) => ({
+        reserveAddress: new PublicKey(r.reserveAddress),
+        marketAddress: new PublicKey(r.marketAddress),
+      })),
+      tokenVault: new PublicKey(json.kaminoVaultData.tokenVault),
+      tokenMint: new PublicKey(json.kaminoVaultData.tokenMint),
+      baseVaultAuthority: new PublicKey(json.kaminoVaultData.baseVaultAuthority),
+      sharesMint: new PublicKey(json.kaminoVaultData.sharesMint),
+    }
+  }
+
+  if (json.splStakePoolData) {
+    result.splStakePoolData = {
+      stakePoolAddress: new PublicKey(json.splStakePoolData.stakePoolAddress),
+      stakePoolProgramId: new PublicKey(json.splStakePoolData.stakePoolProgramId),
+      validatorList: new PublicKey(json.splStakePoolData.validatorList),
+      reserveStake: new PublicKey(json.splStakePoolData.reserveStake),
+      managerFeeAccount: new PublicKey(json.splStakePoolData.managerFeeAccount),
+      poolMint: new PublicKey(json.splStakePoolData.poolMint),
     }
   }
 
@@ -382,11 +539,11 @@ export function fromAdditionalDataGenericJson(json: AdditionalDataGenericJson):
 /** Helper function to extract fragmetric data from additional data */
 export function getFragmetricDataFromAdditionalData(additionalData?: AdditionalDataGeneric):
   | {
-      receiptTokenMint: web3.PublicKey
-      wrappedTokenMint: web3.PublicKey
+      receiptTokenMint: PublicKey
+      wrappedTokenMint: PublicKey
     }
   | undefined {
   if (!additionalData) return undefined
 
   return additionalData.fragmetricData
-}
+}