@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/syPosition.ts

@@ -1,182 +0,0 @@
-import { ExponentFetcher, SyPosition } from "@exponent-labs/exponent-fetcher"
-import {
-  FlavorGeneric,
-  FlavorJitoRestaking,
-  FlavorKamino,
-  FlavorMarginfi,
-  FlavorPerena,
-  IFlavorState,
-  SyPositionJson,
-} from "@exponent-labs/exponent-types"
-import { PROGRAM_ID as GENERIC_STANDARD_PROGRAM_ID } from "@exponent-labs/generic-sy-idl"
-import { GenericSyPda } from "@exponent-labs/generic-sy-pda"
-import { PROGRAM_ID as JITO_RESTAKING_SY_PROGRAM_ID } from "@exponent-labs/jito-restaking-sy-idl"
-import { JitoRestakingSyPda } from "@exponent-labs/jito-restaking-sy-pda"
-import { PROGRAM_ID as KAMINO_STANDARD_PROGRAM_ID } from "@exponent-labs/kamino-sy-idl"
-import { KaminoSyPda } from "@exponent-labs/kamino-sy-pda"
-import { MarginfiSyPda } from "@exponent-labs/marginfi-sy-pda"
-import { PROGRAM_ID as PERENA_STANDARD_PROGRAM_ID } from "@exponent-labs/perena-sy-idl"
-import { PerenaSyPda } from "@exponent-labs/perena-sy-pda"
-
-import {
-  makeFlavorJitoRestakingSync,
-  makeFlavorKaminoSync,
-  makeFlavorMarginfiSync,
-  makeFlavorPerenaSync,
-} from "./flavors"
-import { PublicKey } from "@solana/web3.js"
-
-export function deserializeSyPosition(syPosition: SyPositionJson): SyPosition {
-  return {
-    balanceSy: BigInt(syPosition.balanceSy),
-    owner: new PublicKey(syPosition.owner),
-    emissions: syPosition.emissions.map((emission) => ({
-      lastSeenIndex: emission.lastSeenIndex,
-      mint: new PublicKey(emission.mint),
-      staged: BigInt(emission.staged),
-    })),
-  }
-}
-
-export function serializeSyPosition(syPosition: SyPosition): SyPositionJson {
-  return {
-    balanceSy: syPosition.balanceSy.toString(),
-    owner: syPosition.owner.toString(),
-    emissions: syPosition.emissions.map((emission) => ({
-      ...emission,
-      mint: emission.mint.toString(),
-      staged: emission.staged.toString(),
-    })),
-  }
-}
-
-export async function makeSyPosition(
-  fetcher: ExponentFetcher,
-  flavor: IFlavorState,
-  syProgramId: PublicKey,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  if (flavor.flavor === "marginfi") {
-    const marginfiFlavor = makeFlavorMarginfiSync(flavor)
-    return makeSyPositionMarginfi(fetcher, syProgramId, marginfiFlavor, owner)
-  }
-
-  if (flavor.flavor === "kamino") {
-    const kaminoFlavor = makeFlavorKaminoSync(flavor)
-    return makeSyPositionKamino(fetcher, kaminoFlavor, owner)
-  }
-
-  if (flavor.flavor === "jitoRestaking") {
-    const jitoRestakingFlavor = makeFlavorJitoRestakingSync(flavor)
-    return makeSyPositionJitoRestaking(fetcher, jitoRestakingFlavor, owner)
-  }
-
-  if (flavor.flavor === "perena") {
-    const perenaFlavor = makeFlavorPerenaSync(flavor)
-    return makeSyPositionPerena(fetcher, perenaFlavor, owner)
-  }
-
-  if (flavor.flavor === "generic") {
-    return makeSyPositionGeneric(fetcher, flavor as FlavorGeneric, owner)
-  }
-
-  throw new Error("Unsupported flavor")
-}
-
-async function makeSyPositionMarginfi(
-  fetcher: ExponentFetcher,
-  marginfiProgramId: PublicKey,
-  flavor: FlavorMarginfi,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  const pda = new MarginfiSyPda(marginfiProgramId)
-  const bank = flavor.bank
-  const positionAddress = pda.position({ bank, signer: owner })
-  const position = await fetcher.fetchMarginfiSyPosition(positionAddress)
-  return position
-}
-
-async function makeSyPositionKamino(
-  fetcher: ExponentFetcher,
-  flavor: FlavorKamino,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  const reserve = flavor.kaminoSyState.account.kaminoReserve
-  const pda = new KaminoSyPda(new PublicKey(KAMINO_STANDARD_PROGRAM_ID))
-  const positionAddress = pda.position({ reserve, owner })
-  const position = await fetcher.fetchKaminoSyPosition(positionAddress)
-  return position
-}
-
-async function makeSyPositionJitoRestaking(
-  fetcher: ExponentFetcher,
-  flavor: FlavorJitoRestaking,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  const jitoVault = flavor.jitoSyState.account.jitoVault
-  const pda = new JitoRestakingSyPda(new PublicKey(JITO_RESTAKING_SY_PROGRAM_ID))
-  const positionAddress = pda.position({ jitoVault, owner })
-  const position = await fetcher.fetchJitoRestakingSyPosition(positionAddress)
-  return position
-}
-
-async function makeSyPositionPerena(
-  fetcher: ExponentFetcher,
-  flavor: FlavorPerena,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  const perenaStablePool = flavor.perenaSyState.account.perenaStablePool
-  const pda = new PerenaSyPda(new PublicKey(PERENA_STANDARD_PROGRAM_ID))
-  const positionAddress = pda.position({ owner, perenaStablePool })
-  const position = await fetcher.fetchPerenaSyPosition(positionAddress)
-  return position
-}
-
-async function makeSyPositionGeneric(
-  fetcher: ExponentFetcher,
-  flavor: FlavorGeneric,
-  owner: PublicKey,
-): Promise<SyPosition> {
-  const yieldBearingMint = flavor.genericSyState.account.yieldBearingMint
-  const interfaceType = flavor.genericSyState.account.interfaceType
-
-  let interfaceIndex: number
-  if ("pyth" in interfaceType) {
-    interfaceIndex = 0 // InterfaceType.Pyth
-  } else if ("splStakePool" in interfaceType) {
-    interfaceIndex = 1 // InterfaceType.SplStakePool
-  } else if ("one" in interfaceType) {
-    interfaceIndex = 2 // InterfaceType.One
-  } else if ("fragmetric" in interfaceType) {
-    interfaceIndex = 3 // InterfaceType.Fragmetric
-  } else if ("meteora" in interfaceType) {
-    interfaceIndex = 4 // InterfaceType.Meteora
-  } else if ("fragmetricSupportedAsset" in interfaceType) {
-    interfaceIndex = 5 // InterfaceType.FragmetricSupportedAsset
-  } else if ("sanctum" in interfaceType) {
-    interfaceIndex = 6 // InterfaceType.Sanctum
-  } else if ("jupiterPerps" in interfaceType) {
-    interfaceIndex = 7 // InterfaceType.JupiterPerps
-  } else if ("adrena" in interfaceType) {
-    interfaceIndex = 8 // InterfaceType.Adrena
-  } else if ("hyloLpToken" in interfaceType) {
-    interfaceIndex = 9 // InterfaceType.HyloLpToken
-  } else if ("jupiterLend" in interfaceType) {
-    interfaceIndex = 10 // InterfaceType.JupiterLend
-  } else if ("kaminoVault" in interfaceType) {
-    interfaceIndex = 11 // InterfaceType.KaminoVault
-  } else if ("solstice" in interfaceType) {
-    interfaceIndex = 12 // InterfaceType.Solstice
-  } else if ("reflect" in interfaceType) {
-    interfaceIndex = 13 // InterfaceType.Reflect
-  } else if ("ore" in interfaceType) {
-    interfaceIndex = 14 // InterfaceType.Ore
-  } else {
-    throw new Error("Unsupported interface type")
-  }
-
-  const pda = new GenericSyPda(new PublicKey(GENERIC_STANDARD_PROGRAM_ID), interfaceIndex)
-  const positionAddress = pda.position({ owner, yieldBearingMint })
-  const position = await fetcher.fetchGenericSyPosition(positionAddress)
-  return position
-}

package/src/tokenUtil.ts

@@ -1,23 +0,0 @@
-import { MintLayout } from "@solana/spl-token"
-import { Connection, PublicKey } from "@solana/web3.js"
-
-export async function getMintSupply(connection: Connection, address: PublicKey): Promise<bigint> {
-  const mintInfo = await connection.getAccountInfo(address)
-  if (mintInfo === null) {
-    throw new Error("Failed to find mint account")
-  }
-  return MintLayout.decode(mintInfo.data).supply
-}
-
-export async function getMultipleMintSupply(
-  connection: Connection,
-  addresses: PublicKey[],
-): Promise<bigint[]> {
-  const mintInfos = await connection.getMultipleAccountsInfo(addresses)
-  return mintInfos.map((mintInfo) => {
-    if (mintInfo === null) {
-      throw new Error("Failed to find mint account")
-    }
-    return MintLayout.decode(mintInfo.data).supply
-  })
-}

package/src/utils/altUtil.ts

@@ -1,52 +0,0 @@
-import * as web3 from "@solana/web3.js"
-
-import { AccountInfo, CpiAccountIndex, CpiAccountIndexes, CpiAccountsRaw } from "@exponent-labs/exponent-types"
-
-export function extendAddressLookupTable(
-  oldAlt: web3.PublicKey[],
-  cpiAccountsRaw: CpiAccountsRaw,
-): {
-  cpiAccountIndexes: CpiAccountIndexes
-  addressLookupTableExtension: web3.PublicKey[]
-} {
-  const allPubkeys = getAllPubkeysFromCpiAccountsRaw(cpiAccountsRaw)
-
-  const newPubkeys = allPubkeys.filter((p) => !oldAlt.some((o) => o.equals(p)))
-  const addressLookupTableExtension = Array.from(new Set(newPubkeys))
-
-  const newAlt = [...oldAlt, ...addressLookupTableExtension]
-
-  // Find index in ALT for a pubkey
-  const toIndex = (pubkey: web3.PublicKey) => newAlt.map((x) => x.toBase58()).indexOf(pubkey.toBase58())
-
-  // convert an AccountInfo to a CpiAccountIndex
-  const toCpiAccountIndex = (a: AccountInfo): CpiAccountIndex => ({
-    altIndex: toIndex(a.pubkey),
-    isSigner: a.isSigner,
-    isWritable: a.isWritable,
-  })
-
-  const cpiAccountIndexes: CpiAccountIndexes = {
-    getSyState: cpiAccountsRaw.getSyState.map(toCpiAccountIndex),
-    withdrawSy: cpiAccountsRaw.withdrawSy.map(toCpiAccountIndex),
-    depositSy: cpiAccountsRaw.depositSy.map(toCpiAccountIndex),
-    claimEmission: cpiAccountsRaw.claimEmission.map((a) => a.map(toCpiAccountIndex)),
-    getPositionState: cpiAccountsRaw.getPositionState.map(toCpiAccountIndex),
-  }
-
-  return {
-    cpiAccountIndexes,
-    addressLookupTableExtension,
-  }
-}
-
-/** Get all pubkeys from CpiAccountsRaw */
-export function getAllPubkeysFromCpiAccountsRaw(cpiAccountsRaw: CpiAccountsRaw): web3.PublicKey[] {
-  return [
-    ...cpiAccountsRaw.getSyState,
-    ...cpiAccountsRaw.withdrawSy,
-    ...cpiAccountsRaw.depositSy,
-    ...cpiAccountsRaw.claimEmission.flat(),
-    ...cpiAccountsRaw.getPositionState,
-  ].map((a) => a.pubkey)
-}

package/src/utils/binSolver.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "@jest/globals"
-
-import { binSolver } from "./binSolver"
-
-describe("bin solver", () => {
-  it("should return the index of the target value in the array", () => {
-    const fn = (x: number) => x * x
-    const a1 = binSolver(fn, 16, 3)
-    expect(a1).toBeCloseTo(4, 2)
-
-    const a2 = binSolver(fn, 16, 1)
-    expect(a2).toBeCloseTo(4, 2)
-
-    const a3 = binSolver(fn, 16, 10)
-    expect(a3).toBeCloseTo(4, 2)
-  })
-})

package/src/utils/binSolver.ts

@@ -1,44 +0,0 @@
-export function binSolver(fn: (x: number) => number, target: number, guess: number, eps: number = 0.01) {
-  let low = guess
-  let high = guess
-  let iterations = 0
-  const MAX_ITERATIONS = 1000 // Prevent infinite loops
-
-  // check edge case
-  if (fn(guess) === target) {
-    return guess
-  }
-
-  // Expand the range until we encompass the target value
-  while (fn(low) > target || fn(high) < target) {
-    if (fn(low) > target) {
-      high = low
-      low = low / 2
-    } else {
-      low = high
-      high = high * 2
-    }
-    iterations++
-    if (iterations >= MAX_ITERATIONS) return null
-  }
-
-  // Perform binary search within the expanded range
-  while (low < high && iterations < MAX_ITERATIONS) {
-    const mid = (low + high) / 2
-    const value = fn(mid)
-
-    if (Math.abs(value - target) < eps) {
-      return mid // Found a close enough value
-    }
-
-    if (value < target) {
-      low = mid + Number.EPSILON // Ensure progress
-    } else {
-      high = mid - Number.EPSILON // Ensure progress
-    }
-
-    iterations++
-  }
-
-  return null // No solution found within the iteration limit
-}

package/src/utils/index.ts

@@ -1,33 +0,0 @@
-import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
-import { AccountMeta, PublicKey } from "@solana/web3.js"
-
-export type { InstructionAccounts } from "./ix"
-
-export function uniqueRemainingAccounts(xs: AccountMeta[]): AccountMeta[] {
-  const seen: Record<string, AccountMeta> = {}
-
-  for (const x of xs) {
-    const k = x.pubkey.toBase58()
-
-    if (!seen[k]) {
-      seen[k] = x
-      continue
-    }
-
-    const v = seen[k]
-    v.isWritable = v.isWritable || x.isWritable
-    v.isSigner = v.isSigner || x.isSigner
-  }
-
-  return Object.values(seen)
-}
-
-/** Find the authority for event emit with self-cpi */
-export function emitEventAuthority(programId: PublicKey) {
-  return PublicKey.findProgramAddressSync([Buffer.from("__event_authority")], programId)[0]
-}
-
-export function getExponentAdminStatePda() {
-  const exponentAdminPda = new ExponentAdminPda(EXPONENT_ADMIN_PROGRAM_ID)
-  return exponentAdminPda.exponentAdmin()
-}

package/src/utils/ix.ts

@@ -1,7 +0,0 @@
-import { AccountMeta } from "@solana/web3.js"
-
-/** Generic type for accounts used for instructions */
-export type InstructionAccounts<T> = {
-  mainAccounts: T
-  remainingAccounts: AccountMeta[]
-}