@exponent-labs/exponent-sdk 0.0.3

package/src/syPosition.ts

@@ -0,0 +1,151 @@
+import { web3 } from "@coral-xyz/anchor"
+import {
+  makeFlavorJitoRestakingSync,
+  makeFlavorKaminoSync,
+  makeFlavorMarginfiSync,
+  makeFlavorPerenaSync,
+} from "./flavors"
+import { ExponentFetcher, SyPosition } from "@exponent-labs/exponent-fetcher"
+import { MarginfiSyPda } from "@exponent-labs/marginfi-sy-pda"
+import { getPosition, KAMINO_STANDARD_PROGRAM_ID } from "@exponent-labs/kamino-lend-standard"
+import { JitoRestakingSyPda } from "@exponent-labs/jito-restaking-sy-pda"
+import { PROGRAM_ID as PERENA_STANDARD_PROGRAM_ID } from "@exponent-labs/perena-sy-idl"
+import { PROGRAM_ID as GENERIC_STANDARD_PROGRAM_ID } from "@exponent-labs/generic-sy-idl"
+import {
+  FlavorMarginfi,
+  FlavorKamino,
+  SyPositionJson,
+  IFlavorState,
+  FlavorJitoRestaking,
+  FlavorPerena,
+  FlavorGeneric,
+} from "@exponent-labs/exponent-types"
+import { PROGRAM_ID as JITO_RESTAKING_SY_PROGRAM_ID } from "@exponent-labs/jito-restaking-sy-idl"
+import { PerenaSyPda } from "@exponent-labs/perena-sy-pda"
+import { GenericSyPda } from "@exponent-labs/generic-sy-pda"
+
+export function deserializeSyPosition(syPosition: SyPositionJson): SyPosition {
+  return {
+    balanceSy: BigInt(syPosition.balanceSy),
+    owner: new web3.PublicKey(syPosition.owner),
+    emissions: syPosition.emissions.map((emission) => ({
+      lastSeenIndex: emission.lastSeenIndex,
+      mint: new web3.PublicKey(emission.mint),
+      staged: BigInt(emission.staged),
+    })),
+  }
+}
+
+export function serializeSyPostion(syPostion: SyPosition): SyPositionJson {
+  return {
+    balanceSy: syPostion.balanceSy.toString(),
+    owner: syPostion.owner.toString(),
+    emissions: syPostion.emissions.map((emission) => ({
+      ...emission,
+      mint: emission.mint.toString(),
+      staged: emission.staged.toString(),
+    })),
+  }
+}
+
+export async function makeSyPosition(
+  fetcher: ExponentFetcher,
+  flavor: IFlavorState,
+  syProgramId: web3.PublicKey,
+  owner: web3.PublicKey,
+): Promise<SyPosition> {
+  if (flavor.flavor === "marginfi") {
+    const marginfiFlavor = makeFlavorMarginfiSync(flavor)
+    return makeSyPositionMarginfi(fetcher, syProgramId, marginfiFlavor, owner)
+  } else if (flavor.flavor === "kamino") {
+    const kaminoFlavor = makeFlavorKaminoSync(flavor)
+    return makeSyPositionKamino(fetcher, kaminoFlavor, owner)
+  } else if (flavor.flavor === "jitoRestaking") {
+    const jitoRestakingFlavor = makeFlavorJitoRestakingSync(flavor)
+    return makeSyPositionJitoRestaking(fetcher, jitoRestakingFlavor, owner)
+  } else if (flavor.flavor === "perena") {
+    const perenaFlavor = makeFlavorPerenaSync(flavor)
+    return makeSyPositionPerena(fetcher, perenaFlavor, owner)
+  } else if (flavor.flavor === "generic") {
+    return makeSyPositionGeneric(fetcher, flavor as FlavorGeneric, owner)
+  }
+
+  throw new Error("Unsupported flavor")
+}
+
+async function makeSyPositionMarginfi(
+  fetcher: ExponentFetcher,
+  marginfiProgramId: web3.PublicKey,
+  flavor: FlavorMarginfi,
+  owner: web3.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: web3.PublicKey,
+): Promise<SyPosition> {
+  const reserve = flavor.kaminoSyState.account.kaminoReserve
+  const positionAddress = getPosition(reserve, owner, KAMINO_STANDARD_PROGRAM_ID)
+  const position = await fetcher.fetchKaminoSyPosition(positionAddress)
+  return position
+}
+
+async function makeSyPositionJitoRestaking(
+  fetcher: ExponentFetcher,
+  flavor: FlavorJitoRestaking,
+  owner: web3.PublicKey,
+): Promise<SyPosition> {
+  const jitoVault = flavor.jitoSyState.account.jitoVault
+  const pda = new JitoRestakingSyPda(new web3.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: web3.PublicKey,
+): Promise<SyPosition> {
+  const perenaStablePool = flavor.perenaSyState.account.perenaStablePool
+  const pda = new PerenaSyPda(new web3.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: web3.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 {
+    throw new Error("Unsupported interface type")
+  }
+
+  const pda = new GenericSyPda(new web3.PublicKey(GENERIC_STANDARD_PROGRAM_ID), interfaceIndex)
+  const positionAddress = pda.position({ owner, yieldBearingMint })
+  const position = await fetcher.fetchGenericSyPosition(positionAddress)
+  return position
+}

package/src/tokenUtil.ts

@@ -0,0 +1,20 @@
+import { web3 } from "@coral-xyz/anchor"
+import { MintLayout } from "@solana/spl-token"
+
+export async function getMintSupply(cnx: web3.Connection, address: web3.PublicKey): Promise<bigint> {
+  const mintInfo = await cnx.getAccountInfo(address)
+  if (mintInfo === null) {
+    throw new Error("Failed to find mint account")
+  }
+  return MintLayout.decode(mintInfo.data).supply
+}
+
+export async function getMultipleMintSupply(cnx: web3.Connection, addresses: web3.PublicKey[]): Promise<bigint[]> {
+  const mintInfos = await cnx.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

@@ -0,0 +1,47 @@
+import * as web3 from "@solana/web3.js"
+import { CpiAccountsRaw, CpiAccountIndexes, CpiAccountIndex, AccountInfo } from "@exponent-labs/exponent-types"
+
+export function extendAddressLookupTable(
+  oldAlt: web3.PublicKey[],
+  c: CpiAccountsRaw,
+): {
+  cpiAccountIndexes: CpiAccountIndexes
+  addressLookupTableExtension: web3.PublicKey[]
+} {
+  const allPubkeys = getAllPubkeysFromCpiAccountsRaw(c)
+
+  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: c.getSyState.map(toCpiAccountIndex),
+    withdrawSy: c.withdrawSy.map(toCpiAccountIndex),
+    depositSy: c.depositSy.map(toCpiAccountIndex),
+    claimEmission: c.claimEmission.map((a) => a.map(toCpiAccountIndex)),
+    getPositionState: c.getPositionState.map(toCpiAccountIndex),
+  }
+
+  return {
+    cpiAccountIndexes,
+    addressLookupTableExtension,
+  }
+}
+
+/** Get all pubkeys from CpiAccountsRaw */
+export function getAllPubkeysFromCpiAccountsRaw(c: CpiAccountsRaw): web3.PublicKey[] {
+  return [...c.getSyState, ...c.withdrawSy, ...c.depositSy, ...c.claimEmission.flat(), ...c.getPositionState].map(
+    (a) => a.pubkey,
+  )
+}

package/src/utils/binSolver.test.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,32 @@
+import { web3 } from "@coral-xyz/anchor"
+import { EXPONENT_ADMIN_PROGRAM_ID, ExponentAdminPda } from "@exponent-labs/exponent-admin-pda"
+export { InstructionAccounts } from "./ix"
+
+export function uniqueRemainingAccounts(xs: web3.AccountMeta[]): web3.AccountMeta[] {
+  const seen: Record<string, web3.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: web3.PublicKey) {
+  return web3.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

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