@exponent-labs/exponent-sdk 0.9.1 → 0.9.3

package/src/flavors.ts

@@ -1,841 +0,0 @@
-
-import { ExponentFetcher, fetchKaminoReserve } from "@exponent-labs/exponent-fetcher"
-import {
-  CpiAccountsRaw,
-  Flavor,
-  FlavorDiscriminator,
-  FlavorGeneric,
-  FlavorGenericState,
-  FlavorGenericStateJson,
-  FlavorJitoRestaking,
-  FlavorJitoRestakingState,
-  FlavorJitoRestakingStateJson,
-  FlavorKamino,
-  FlavorKaminoState,
-  FlavorKaminoStateJson,
-  FlavorMarginfi,
-  FlavorMarginfiState,
-  FlavorMarginfiStateJson,
-  FlavorPerena,
-  FlavorPerenaState,
-  FlavorPerenaStateJson,
-  MintSyArgs,
-  RedeemSyArgs,
-  fromAdditionalDataGenericJson,
-  fromInterfaceTypeGenericJson,
-  toAdditionalDataGenericJson,
-  toInterfaceTypeGenericJson,
-} from "@exponent-labs/exponent-types"
-import { GenericSySdk } from "@exponent-labs/generic-sy-sdk"
-import { JitoRestakingSySdk } from "@exponent-labs/jito-restaking-sy-sdk"
-import { PROGRAM_ID as KAMINO_STANDARD_PROGRAM_ID } from "@exponent-labs/kamino-sy-idl"
-import { KaminoSyPda } from "@exponent-labs/kamino-sy-pda"
-import { KlendSySdk } from "@exponent-labs/kamino-sy-sdk"
-import { MfiSySdk } from "@exponent-labs/marginfi-sy-sdk"
-import { PerenaSySdk } from "@exponent-labs/perena-sy-sdk"
-import { PreciseNumber } from "@exponent-labs/precise-number"
-
-import { Environment } from "./environment"
-import BN from 'bn.js'
-import { PublicKey } from "@solana/web3.js"
-
-export function serializeFlavorMarginfi(flavor: FlavorMarginfiState): FlavorMarginfiStateJson {
-  return {
-    flavor: "marginfi",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: flavor.mintBase.toString(),
-    baseTokenProgram: flavor.baseTokenProgram.toString(),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: parseFloat(PreciseNumber.fromRaw(e.exchangeRate[0]).valueString),
-      mint: e.mint.toString(),
-      tokenProgram: e.tokenProgram.toString(),
-    })),
-    bank: flavor.bank.toString(),
-    emissionMint: flavor.emissionMint?.toString(),
-    emissionTokenProgram: flavor.emissionTokenProgram?.toString(),
-    mfiSyState: {
-      selfAddress: flavor.mfiSyState.selfAddress.toString(),
-      marginfiSyProgramId: flavor.mfiSyState.marginfiSyProgramId.toString(),
-      syRate: flavor.mfiSyState.syRate,
-      mintBase: flavor.mfiSyState.mintBase.toString(),
-      tokenProgramBase: flavor.mfiSyState.tokenProgramBase.toString(),
-      marginfiProgramId: flavor.mfiSyState.marginfiProgramId.toString(),
-      marginfiGroupId: flavor.mfiSyState.marginfiGroupId.toString(),
-      emissionsMint: flavor.mfiSyState.emissionsMint?.toString() || null,
-      emissionsTokenProgram: flavor.mfiSyState.emissionsTokenProgram?.toString() || null,
-      account: {
-        marginfiBank: flavor.mfiSyState.account.marginfiBank.toString(),
-        marginfiAccount: flavor.mfiSyState.account.marginfiAccount.toString(),
-        mintSy: flavor.mfiSyState.account.mintSy.toString(),
-        tokenSyEscrow: flavor.mfiSyState.account.tokenSyEscrow.toString(),
-        maxSySupply: flavor.mfiSyState.account.maxSySupply.toString(),
-        minMintSize: flavor.mfiSyState.account.minMintSize.toString(),
-        minRedeemSize: flavor.mfiSyState.account.minRedeemSize.toString(),
-        emissions: flavor.mfiSyState.account.emissions.map((e) => ({
-          mint: e.mint.toString(),
-          tokenProgram: e.tokenProgram.toString(),
-          escrowAccount: e.escrowAccount.toString(),
-          index: parseFloat(PreciseNumber.fromRaw(e.index[0]).valueString),
-          lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
-          lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions.toString(),
-          totalClaimedEmissions: e.totalClaimedEmissions.toString(),
-          treasuryEmission: e.treasuryEmission.toString(),
-        })),
-      },
-    },
-  }
-}
-
-export function deserializeFlavorMarginfi(flavor: FlavorMarginfiStateJson): FlavorMarginfiState {
-  return {
-    flavor: "marginfi",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: new PublicKey(flavor.mintBase),
-    baseTokenProgram: new PublicKey(flavor.baseTokenProgram),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
-      mint: new PublicKey(e.mint),
-      tokenProgram: new PublicKey(e.tokenProgram),
-    })),
-    bank: new PublicKey(flavor.bank),
-    emissionMint: flavor.emissionMint ? new PublicKey(flavor.emissionMint) : undefined,
-    emissionTokenProgram: flavor.emissionTokenProgram ? new PublicKey(flavor.emissionTokenProgram) : undefined,
-    mfiSyState: {
-      selfAddress: new PublicKey(flavor.mfiSyState.selfAddress),
-      marginfiSyProgramId: new PublicKey(flavor.mfiSyState.marginfiSyProgramId),
-      syRate: flavor.mfiSyState.syRate,
-      mintBase: new PublicKey(flavor.mfiSyState.mintBase),
-      tokenProgramBase: new PublicKey(flavor.mfiSyState.tokenProgramBase),
-      marginfiProgramId: new PublicKey(flavor.mfiSyState.marginfiProgramId),
-      marginfiGroupId: new PublicKey(flavor.mfiSyState.marginfiGroupId),
-      emissionsMint: flavor.mfiSyState.emissionsMint ? new PublicKey(flavor.mfiSyState.emissionsMint) : null,
-      emissionsTokenProgram: flavor.mfiSyState.emissionsTokenProgram
-        ? new PublicKey(flavor.mfiSyState.emissionsTokenProgram)
-        : null,
-      account: {
-        marginfiBank: new PublicKey(flavor.mfiSyState.account.marginfiBank),
-        marginfiAccount: new PublicKey(flavor.mfiSyState.account.marginfiAccount),
-        mintSy: new PublicKey(flavor.mfiSyState.account.mintSy),
-        tokenSyEscrow: new PublicKey(flavor.mfiSyState.account.tokenSyEscrow),
-        maxSySupply: BigInt(flavor.mfiSyState.account.maxSySupply),
-        minMintSize: BigInt(flavor.mfiSyState.account.minMintSize),
-        minRedeemSize: BigInt(flavor.mfiSyState.account.minRedeemSize),
-        emissions: flavor.mfiSyState.account.emissions.map((emission) => ({
-          mint: new PublicKey(emission.mint),
-          tokenProgram: new PublicKey(emission.tokenProgram),
-          escrowAccount: new PublicKey(emission.escrowAccount),
-          index: new PreciseNumber(emission.index.toString()).anchorify(),
-          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
-          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
-          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
-          treasuryEmission: new BN(emission.treasuryEmission),
-        })),
-      },
-    },
-  }
-}
-
-export function serializeFlavorKamino(flavor: FlavorKaminoState): FlavorKaminoStateJson {
-  return {
-    flavor: "kamino",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: flavor.mintBase.toString(),
-    baseTokenProgram: flavor.baseTokenProgram.toString(),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: parseFloat(PreciseNumber.fromRaw(e.exchangeRate[0]).valueString),
-      mint: e.mint.toString(),
-      tokenProgram: e.tokenProgram.toString(),
-    })),
-    kaminoSyState: {
-      selfAddress: flavor.kaminoSyState.selfAddress.toString(),
-      klendSyProgramId: flavor.kaminoSyState.klendSyProgramId.toString(),
-      syRate: flavor.kaminoSyState.syRate,
-      mintBase: flavor.kaminoSyState.mintBase.toString(),
-      tokenProgramBase: flavor.kaminoSyState.tokenProgramBase.toString(),
-      klendProgramId: flavor.kaminoSyState.klendProgramId.toString(),
-      klendMarketId: flavor.kaminoSyState.klendMarketId.toString(),
-      scopePriceFeed: flavor.kaminoSyState.scopePriceFeed?.toString(),
-      account: {
-        kaminoReserve: flavor.kaminoSyState.account.kaminoReserve.toString(),
-        kaminoObligation: flavor.kaminoSyState.account.kaminoObligation.toString(),
-        kaminoFarm: flavor.kaminoSyState.account.kaminoFarm.toString(),
-        kaminoUserMetadata: flavor.kaminoSyState.account.kaminoUserMetadata.toString(),
-        mintSy: flavor.kaminoSyState.account.mintSy.toString(),
-        tokenSyEscrow: flavor.kaminoSyState.account.tokenSyEscrow.toString(),
-        minMintSize: flavor.kaminoSyState.account.minMintSize.toString(),
-        minRedeemSize: flavor.kaminoSyState.account.minRedeemSize.toString(),
-        userState: flavor.kaminoSyState.account.userState.toString(),
-        maxSySupply: flavor.kaminoSyState.account.maxSySupply.toString(),
-        emissions: flavor.kaminoSyState.account.emissions.map((e) => ({
-          mint: e.mint.toString(),
-          tokenProgram: e.tokenProgram.toString(),
-          escrowAccount: e.escrowAccount.toString(),
-          index: parseFloat(PreciseNumber.fromRaw(e.index[0]).valueString),
-          lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
-          lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions.toString(),
-          totalClaimedEmissions: e.totalClaimedEmissions.toString(),
-          treasuryEmission: e.treasuryEmission.toString(),
-        })),
-      },
-    },
-  }
-}
-
-export function deserializeFlavorKamino(flavor: FlavorKaminoStateJson): FlavorKaminoState {
-  return {
-    flavor: "kamino",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: new PublicKey(flavor.mintBase),
-    baseTokenProgram: new PublicKey(flavor.baseTokenProgram),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
-      mint: new PublicKey(e.mint),
-      tokenProgram: new PublicKey(e.tokenProgram),
-    })),
-    kaminoSyState: {
-      selfAddress: new PublicKey(flavor.kaminoSyState.selfAddress),
-      klendSyProgramId: new PublicKey(flavor.kaminoSyState.klendSyProgramId),
-      syRate: flavor.kaminoSyState.syRate,
-      mintBase: new PublicKey(flavor.kaminoSyState.mintBase),
-      tokenProgramBase: new PublicKey(flavor.kaminoSyState.tokenProgramBase),
-      klendProgramId: new PublicKey(flavor.kaminoSyState.klendProgramId),
-      klendMarketId: new PublicKey(flavor.kaminoSyState.klendMarketId),
-      scopePriceFeed: flavor.kaminoSyState.scopePriceFeed
-        ? new PublicKey(flavor.kaminoSyState.scopePriceFeed)
-        : undefined,
-      account: {
-        kaminoReserve: new PublicKey(flavor.kaminoSyState.account.kaminoReserve),
-        kaminoObligation: new PublicKey(flavor.kaminoSyState.account.kaminoObligation),
-        kaminoFarm: new PublicKey(flavor.kaminoSyState.account.kaminoFarm),
-        kaminoUserMetadata: new PublicKey(flavor.kaminoSyState.account.kaminoUserMetadata),
-        mintSy: new PublicKey(flavor.kaminoSyState.account.mintSy),
-        tokenSyEscrow: new PublicKey(flavor.kaminoSyState.account.tokenSyEscrow),
-        minMintSize: flavor.kaminoSyState.account.minMintSize,
-        minRedeemSize: flavor.kaminoSyState.account.minRedeemSize,
-        userState: new PublicKey(flavor.kaminoSyState.account.userState),
-        maxSySupply: flavor.kaminoSyState.account.maxSySupply,
-        emissions: flavor.kaminoSyState.account.emissions.map((emission) => ({
-          mint: new PublicKey(emission.mint),
-          tokenProgram: new PublicKey(emission.tokenProgram),
-          escrowAccount: new PublicKey(emission.escrowAccount),
-          index: new PreciseNumber(emission.index.toString()).anchorify(),
-          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
-          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
-          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
-          treasuryEmission: new BN(emission.treasuryEmission),
-        })),
-      },
-    },
-  }
-}
-
-export function serializeFlavorJitoRestaking(flavor: FlavorJitoRestakingState): FlavorJitoRestakingStateJson {
-  return {
-    flavor: "jitoRestaking",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: flavor.mintBase.toString(),
-    baseTokenProgram: flavor.baseTokenProgram.toString(),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: parseFloat(PreciseNumber.fromRaw(e.exchangeRate[0]).valueString),
-      mint: e.mint.toString(),
-      tokenProgram: e.tokenProgram.toString(),
-    })),
-    jitoSyState: {
-      selfAddress: flavor.jitoSyState.selfAddress.toString(),
-      syRate: flavor.jitoSyState.syRate,
-      underlyingExchangeRate: flavor.jitoSyState.underlyingExchangeRate,
-      mintBase: flavor.jitoSyState.mintBase.toString(),
-      tokenProgramBase: flavor.jitoSyState.tokenProgramBase.toString(),
-      account: {
-        jitoVault: flavor.jitoSyState.account.jitoVault.toString(),
-        mintSy: flavor.jitoSyState.account.mintSy.toString(),
-        tokenSyEscrow: flavor.jitoSyState.account.tokenSyEscrow.toString(),
-        minMintSize: flavor.jitoSyState.account.minMintSize.toString(),
-        minRedeemSize: flavor.jitoSyState.account.minRedeemSize.toString(),
-        maxSySupply: flavor.jitoSyState.account.maxSySupply.toString(),
-        interfaceAccounts: flavor.jitoSyState.account.interfaceAccounts.map((a) => a.toString()),
-        interfaceType: flavor.jitoSyState.account.interfaceType,
-        emissions: flavor.jitoSyState.account.emissions.map((e) => ({
-          mint: e.mint.toString(),
-          tokenProgram: e.tokenProgram.toString(),
-          escrowAccount: e.escrowAccount.toString(),
-          index: parseFloat(PreciseNumber.fromRaw(e.index[0]).valueString),
-          lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
-          lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions.toString(),
-          totalClaimedEmissions: e.totalClaimedEmissions.toString(),
-          treasuryEmission: e.treasuryEmission.toString(),
-        })),
-      },
-    },
-  }
-}
-
-export function deserializeFlavorJitoRestaking(flavor: FlavorJitoRestakingStateJson): FlavorJitoRestakingState {
-  return {
-    flavor: "jitoRestaking",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: new PublicKey(flavor.mintBase),
-    baseTokenProgram: new PublicKey(flavor.baseTokenProgram),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
-      mint: new PublicKey(e.mint),
-      tokenProgram: new PublicKey(e.tokenProgram),
-    })),
-    jitoSyState: {
-      selfAddress: new PublicKey(flavor.jitoSyState.selfAddress),
-      syRate: flavor.jitoSyState.syRate,
-      underlyingExchangeRate: flavor.jitoSyState.underlyingExchangeRate,
-      mintBase: new PublicKey(flavor.jitoSyState.mintBase),
-      tokenProgramBase: new PublicKey(flavor.jitoSyState.tokenProgramBase),
-      account: {
-        jitoVault: new PublicKey(flavor.jitoSyState.account.jitoVault),
-        mintSy: new PublicKey(flavor.jitoSyState.account.mintSy),
-        tokenSyEscrow: new PublicKey(flavor.jitoSyState.account.tokenSyEscrow),
-        minMintSize: new BN(flavor.jitoSyState.account.minMintSize),
-        minRedeemSize: new BN(flavor.jitoSyState.account.minRedeemSize),
-        maxSySupply: new BN(flavor.jitoSyState.account.maxSySupply),
-        interfaceAccounts: flavor.jitoSyState.account.interfaceAccounts.map((a) => new PublicKey(a)),
-        interfaceType: flavor.jitoSyState.account.interfaceType,
-        emissions: flavor.jitoSyState.account.emissions.map((emission) => ({
-          mint: new PublicKey(emission.mint),
-          tokenProgram: new PublicKey(emission.tokenProgram),
-          escrowAccount: new PublicKey(emission.escrowAccount),
-          index: new PreciseNumber(emission.index.toString()).anchorify(),
-          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
-          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
-          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
-          treasuryEmission: new BN(emission.treasuryEmission),
-        })),
-      },
-    },
-  }
-}
-
-export function serializeFlavorPerena(flavor: FlavorPerenaState): FlavorPerenaStateJson {
-  return {
-    flavor: "perena",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    baseTokenProgram: flavor.baseTokenProgram.toString(),
-    mintBase: flavor.mintBase.toString(),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: parseFloat(PreciseNumber.fromRaw(e.exchangeRate[0]).valueString),
-      mint: e.mint.toString(),
-      tokenProgram: e.tokenProgram.toString(),
-    })),
-    perenaSyState: {
-      selfAddress: flavor.perenaSyState.selfAddress.toString(),
-      syRate: flavor.perenaSyState.syRate,
-      mintBase: flavor.perenaSyState.lpMint.toString(),
-      tokenProgramBase: flavor.perenaSyState.tokenProgramBase.toString(),
-      underlyingExchangeRate: Number(flavor.perenaSyState.syRate),
-      account: {
-        perenaStablePool: flavor.perenaSyState.account.perenaStablePool.toString(),
-        mintSy: flavor.perenaSyState.account.mintSy.toString(),
-        tokenSyEscrow: flavor.perenaSyState.account.tokenSyEscrow.toString(),
-        minMintSize: flavor.perenaSyState.account.minMintSize.toString(),
-        minRedeemSize: flavor.perenaSyState.account.minRedeemSize.toString(),
-        maxSySupply: flavor.perenaSyState.account.maxSySupply.toString(),
-        emissions: flavor.perenaSyState.account.emissions.map((e) => ({
-          mint: e.mint.toString(),
-          tokenProgram: e.tokenProgram.toString(),
-          escrowAccount: e.escrowAccount.toString(),
-          index: parseFloat(PreciseNumber.fromRaw(e.index[0]).valueString),
-          lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
-          lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions.toString(),
-          totalClaimedEmissions: e.totalClaimedEmissions.toString(),
-          treasuryEmission: e.treasuryEmission.toString(),
-        })),
-        interfaceAccounts: flavor.perenaSyState.account.interfaceAccounts.map((a) => a.toString()),
-      },
-    },
-  }
-}
-
-export function serializeFlavorGeneric(flavor: FlavorGenericState): FlavorGenericStateJson {
-  return {
-    flavor: "generic",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    baseTokenProgram: flavor.baseTokenProgram.toString(),
-    mintBase: flavor.mintBase.toString(),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: parseFloat(PreciseNumber.fromRaw(e.exchangeRate[0]).valueString),
-      mint: e.mint.toString(),
-      tokenProgram: e.tokenProgram.toString(),
-    })),
-    genericSyState: {
-      selfAddress: flavor.genericSyState.selfAddress.toString(),
-      syRate: flavor.genericSyState.syRate,
-      tokenProgramBase: flavor.genericSyState.tokenProgramBase.toString(),
-      additionalData: flavor.genericSyState.additionalData
-        ? toAdditionalDataGenericJson(flavor.genericSyState.additionalData)
-        : undefined,
-      account: {
-        yieldBearingMint: flavor.genericSyState.account.yieldBearingMint.toString(),
-        mintSy: flavor.genericSyState.account.mintSy.toString(),
-        tokenSyEscrow: flavor.genericSyState.account.tokenSyEscrow.toString(),
-        minMintSize: flavor.genericSyState.account.minMintSize.toString(),
-        minRedeemSize: flavor.genericSyState.account.minRedeemSize.toString(),
-        maxSySupply: flavor.genericSyState.account.maxSySupply.toString(),
-        hook: {
-          enabled: flavor.genericSyState.account.hook.enabled,
-          interfaceEmissionsAccountsUntil: flavor.genericSyState.account.hook.interfaceEmissionsAccountsUntil,
-          programId: flavor.genericSyState.account.hook.programId.toString(),
-          preMintHookDiscriminator: flavor.genericSyState.account.hook.preMintHookDiscriminator,
-          postRedeemHookDiscriminator: flavor.genericSyState.account.hook.postRedeemHookDiscriminator,
-        },
-        emissions: flavor.genericSyState.account.emissions.map((e) => ({
-          mint: e.mint.toString(),
-          tokenProgram: e.tokenProgram.toString(),
-          escrowAccount: e.escrowAccount.toString(),
-          index: parseFloat(PreciseNumber.fromRaw(e.index[0]).valueString),
-          lastSeenIndex: parseFloat(PreciseNumber.fromRaw(e.lastSeenIndex[0]).valueString),
-          lastSeenTotalAccruedEmissions: e.lastSeenTotalAccruedEmissions.toString(),
-          totalClaimedEmissions: e.totalClaimedEmissions.toString(),
-          treasuryEmission: e.treasuryEmission.toString(),
-        })),
-        interfaceAccounts: flavor.genericSyState.account.interfaceAccounts.map((a) => a.toString()),
-        interfaceType: toInterfaceTypeGenericJson(flavor.genericSyState.account.interfaceType),
-        index: parseFloat(PreciseNumber.fromRaw(flavor.genericSyState.account.index[0]).valueString),
-      },
-    },
-  }
-}
-
-export function deserializeFlavorPerena(flavor: FlavorPerenaStateJson): FlavorPerenaState {
-  return {
-    flavor: "perena",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    baseTokenProgram: new PublicKey(flavor.baseTokenProgram),
-    mintBase: new PublicKey(flavor.mintBase),
-    perenaSyState: {
-      selfAddress: new PublicKey(flavor.perenaSyState.selfAddress),
-      syRate: flavor.perenaSyState.syRate,
-      account: {
-        perenaStablePool: new PublicKey(flavor.perenaSyState.account.perenaStablePool),
-        mintSy: new PublicKey(flavor.perenaSyState.account.mintSy),
-        tokenSyEscrow: new PublicKey(flavor.perenaSyState.account.tokenSyEscrow),
-        minMintSize: new BN(flavor.perenaSyState.account.minMintSize),
-        minRedeemSize: new BN(flavor.perenaSyState.account.minRedeemSize),
-        maxSySupply: new BN(flavor.perenaSyState.account.maxSySupply),
-        emissions: flavor.perenaSyState.account.emissions.map((emission) => ({
-          mint: new PublicKey(emission.mint),
-          tokenProgram: new PublicKey(emission.tokenProgram),
-          escrowAccount: new PublicKey(emission.escrowAccount),
-          index: new PreciseNumber(emission.index.toString()).anchorify(),
-          lastSeenIndex: new PreciseNumber(emission.lastSeenIndex.toString()).anchorify(),
-          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
-          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
-          treasuryEmission: new BN(emission.treasuryEmission),
-        })),
-        interfaceAccounts: flavor.perenaSyState.account.interfaceAccounts.map((a) => new PublicKey(a)),
-      },
-      lpMint: new PublicKey(flavor.perenaSyState.mintBase),
-      tokenProgramBase: new PublicKey(flavor.perenaSyState.tokenProgramBase),
-    },
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
-      mint: new PublicKey(e.mint),
-      tokenProgram: new PublicKey(e.tokenProgram),
-    })),
-  }
-}
-
-export function deserializeFlavorGeneric(flavor: FlavorGenericStateJson): FlavorGenericState {
-  return {
-    flavor: "generic",
-    currentSyExchangeRate: flavor.currentSyExchangeRate,
-    mintBase: new PublicKey(flavor.mintBase),
-    baseTokenProgram: new PublicKey(flavor.baseTokenProgram),
-    emissions: flavor.emissions.map((e) => ({
-      exchangeRate: new PreciseNumber(e.exchangeRate.toString()).anchorify(),
-      mint: new PublicKey(e.mint),
-      tokenProgram: new PublicKey(e.tokenProgram),
-    })),
-    genericSyState: {
-      selfAddress: new PublicKey(flavor.genericSyState.selfAddress),
-      syRate: flavor.genericSyState.syRate,
-      tokenProgramBase: new PublicKey(flavor.genericSyState.tokenProgramBase),
-      additionalData: flavor.genericSyState.additionalData
-        ? fromAdditionalDataGenericJson(flavor.genericSyState.additionalData)
-        : undefined,
-      account: {
-        mintSy: new PublicKey(flavor.genericSyState.account.mintSy),
-        yieldBearingMint: new PublicKey(flavor.genericSyState.account.yieldBearingMint),
-        tokenSyEscrow: new PublicKey(flavor.genericSyState.account.tokenSyEscrow),
-        interfaceAccounts: flavor.genericSyState.account.interfaceAccounts.map((a) => new PublicKey(a)),
-        interfaceType: fromInterfaceTypeGenericJson(flavor.genericSyState.account.interfaceType),
-        maxSySupply: new BN(flavor.genericSyState.account.maxSySupply),
-        minMintSize: new BN(flavor.genericSyState.account.minMintSize),
-        minRedeemSize: new BN(flavor.genericSyState.account.minRedeemSize),
-        hook: {
-          enabled: flavor.genericSyState.account.hook.enabled,
-          interfaceEmissionsAccountsUntil: flavor.genericSyState.account.hook.interfaceEmissionsAccountsUntil,
-          preMintHookDiscriminator: Array.from(flavor.genericSyState.account.hook.preMintHookDiscriminator),
-          postRedeemHookDiscriminator: Array.from(flavor.genericSyState.account.hook.postRedeemHookDiscriminator),
-          programId: new PublicKey(flavor.genericSyState.account.hook.programId),
-        },
-        emissions: flavor.genericSyState.account.emissions.map((e) => ({
-          mint: new PublicKey(e.mint),
-          tokenProgram: new PublicKey(e.tokenProgram),
-          escrowAccount: new PublicKey(e.escrowAccount),
-          index: new PreciseNumber(e.index.toString()).anchorify(),
-          lastSeenIndex: new PreciseNumber(e.lastSeenIndex.toString()).anchorify(),
-          lastSeenTotalAccruedEmissions: new BN(e.lastSeenTotalAccruedEmissions),
-          totalClaimedEmissions: new BN(e.totalClaimedEmissions),
-          treasuryEmission: new BN(e.treasuryEmission),
-        })),
-        index: new PreciseNumber(flavor.genericSyState.account.index.toString()).anchorify(),
-      },
-    },
-  }
-}
-
-/** Synchronous version to create Marginfi Flavor from data */
-export function makeFlavorMarginfiSync(data: FlavorMarginfiState): FlavorMarginfi {
-  const mfiSySdk = new MfiSySdk(data.mfiSyState)
-  return {
-    ...data,
-    flavor: "marginfi",
-    ixMintSy: (args) => mfiSySdk.ixMintSy(args),
-    ixRedeemSy: (args) => mfiSySdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
-  }
-}
-
-export function makeFlavorKaminoSync(data: FlavorKaminoState): FlavorKamino {
-  const klendSdk = new KlendSySdk(data.kaminoSyState)
-
-  return {
-    ...data,
-    flavor: "kamino",
-    ixMintSy: (args) => klendSdk.ixMintSy(args),
-    ixRedeemSy: (args) => klendSdk.ixRedeemSy(args),
-    preIxs: async (args) => klendSdk.ixRefreshObligationAndFarms(args.signer),
-    postIxs: async (args) => [klendSdk.ixRefreshObligationAndFarms(args.signer)[2]],
-  }
-}
-
-export function makeFlavorJitoRestakingSync(data: FlavorJitoRestakingState): FlavorJitoRestaking {
-  const jitoSdk = new JitoRestakingSySdk(data.jitoSyState)
-
-  return {
-    ...data,
-    flavor: "jitoRestaking",
-    ixMintSy: (args) => jitoSdk.ixMintSy(args),
-    ixRedeemSy: (args) => jitoSdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
-  }
-}
-
-export function makeFlavorPerenaSync(data: FlavorPerenaState): FlavorPerena {
-  const sySdk = new PerenaSySdk(data.perenaSyState)
-  return {
-    ...data,
-    flavor: "perena",
-    ixMintSy: (args) => sySdk.ixMintSy(args),
-    ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
-  }
-}
-
-export function makeFlavorGenericSync(data: FlavorGenericState, syConfig?: { skipWrap?: boolean }): FlavorGeneric {
-  const sySdk = new GenericSySdk(data.genericSyState, undefined, syConfig)
-  return {
-    ...data,
-    flavor: "generic",
-    ixMintSy: (args) => sySdk.ixMintSy(args),
-    ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
-    preIxs: async () => [...sySdk.preInstructions()],
-    postIxs: async () => [],
-  }
-}
-
-export function flavorFinder(env: Environment, syProgram: PublicKey): FlavorDiscriminator {
-  if (env.marginfiSyProgramId?.equals(syProgram)) {
-    return "marginfi"
-  } else if (env.kaminoSyProgramId?.equals(syProgram)) {
-    return "kamino"
-  } else if (env.jitoRestakingSyProgramId?.equals(syProgram)) {
-    return "jitoRestaking"
-  } else if (env.perenaSyProgramId?.equals(syProgram)) {
-    return "perena"
-  } else if (env.genericSyProgramId?.equals(syProgram)) {
-    return "generic"
-  } else {
-    throw new Error("Unknown flavor")
-  }
-}
-
-export async function makeFlavor(
-  fetcher: ExponentFetcher,
-  env: Environment,
-  /** The actual SY program linked to the market */
-  syProgram: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-  syConfig?: { skipWrap?: boolean },
-): Promise<Flavor> {
-  const fd = flavorFinder(env, syProgram)
-  if (fd === "marginfi") {
-    return makeMarginfiFlavor(fetcher, env.marginfiSyProgramId, cpiAccounts)
-  } else if (fd === "kamino") {
-    return makeKaminoFlavor(fetcher, env.kaminoSyProgramId, cpiAccounts)
-  } else if (fd === "jitoRestaking") {
-    return makeJitoRestakingFlavor(fetcher, env.jitoRestakingSyProgramId, cpiAccounts)
-  } else if (fd === "perena") {
-    return makePerenaFlavor(fetcher, env.perenaSyProgramId, cpiAccounts)
-  } else if (fd === "generic") {
-    return makeGenericFlavor(fetcher, env.genericSyProgramId, cpiAccounts, syConfig)
-  }
-
-  throw new Error("Unknown flavor")
-}
-
-async function makeMarginfiFlavor(
-  fetcher: ExponentFetcher,
-  marginfiSyProgramId: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-): Promise<FlavorMarginfi> {
-  /** Solana's convention is to use the Program ID for the account address if the account is null */
-  const isNone = (x: PublicKey) => x.equals(marginfiSyProgramId)
-  const mapOptAccount = (x: PublicKey) => (isNone(x) ? undefined : x)
-
-  // TODO - I do not like hard-coding these magic numbers
-  const bank = cpiAccounts.getSyState[2].pubkey
-  const emissionMint = cpiAccounts.getSyState[5].pubkey
-  const emissionTokenProgram = cpiAccounts.getSyState[11].pubkey
-
-  const mfiSySdk = await MfiSySdk.load({
-    cnx: fetcher.connection,
-    mfiBank: bank,
-    mfiSyProgramId: marginfiSyProgramId,
-  })
-  const currentSyExchangeRate = Number(mfiSySdk.state.syRate)
-  const emissions = mfiSySdk.account.emissions.map((e) => ({
-    exchangeRate: e.index,
-    mint: e.mint,
-    tokenProgram: e.tokenProgram,
-  }))
-  const ixMintSy = (args: MintSyArgs) => mfiSySdk.ixMintSy(args)
-  const ixRedeemSy = (args: RedeemSyArgs) => mfiSySdk.ixRedeemSy(args)
-  const mintBase = mfiSySdk.mintBase
-  const baseTokenProgram = mfiSySdk.tokenProgramBase
-
-  return {
-    flavor: "marginfi",
-    ixMintSy,
-    ixRedeemSy,
-    currentSyExchangeRate,
-    emissions,
-    bank,
-    mintBase,
-    baseTokenProgram,
-    mfiSyState: mfiSySdk.state,
-    emissionMint: mapOptAccount(emissionMint),
-    emissionTokenProgram: mapOptAccount(emissionTokenProgram),
-    preIxs: async () => [],
-    postIxs: async () => [],
-  }
-}
-
-async function makeKaminoFlavor(
-  fetcher: ExponentFetcher,
-  kaminoSyProgramId: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-): Promise<FlavorKamino> {
-  // TODO - I do not like hard-coding these magic numbers
-  const reserve = cpiAccounts.getSyState[0].pubkey
-  const reserveAcct = await fetchKaminoReserve(reserve, fetcher.connection)
-
-  const mintBase = reserveAcct.baseMint
-
-  // TODO - don't do this
-  // Type error: 'a' is possibly 'null'.
-  // @ts-ignore
-  const baseTokenProgram = await fetcher.connection.getAccountInfo(mintBase).then((a) => a.owner)
-
-  const pda = new KaminoSyPda(new PublicKey(KAMINO_STANDARD_PROGRAM_ID))
-  const meta = pda.syMeta({ kaminoReserve: reserve })
-
-  const syMeta = await fetcher.fetchKaminoSyMeta(meta)
-
-  const klendSdk = await KlendSySdk.load({
-    cnx: fetcher.connection,
-    klendMarketId: reserveAcct.lendingMarket,
-    klendReserve: reserve,
-    klendSyProgramId: kaminoSyProgramId,
-  })
-
-  return {
-    flavor: "kamino",
-    currentSyExchangeRate: reserveAcct.assetShareValue.toNumber(),
-    kaminoSyState: klendSdk.state,
-    emissions: syMeta.emissions.map((e) => ({
-      exchangeRate: e.lastSeenIndex,
-      mint: e.mint,
-      tokenProgram: e.tokenProgram,
-    })),
-    mintBase,
-    baseTokenProgram,
-    ixMintSy: (args) => {
-      return klendSdk.ixMintSy(args)
-    },
-    ixRedeemSy: (args) => {
-      return klendSdk.ixRedeemSy(args)
-    },
-    preIxs: async (args) => klendSdk.ixRefreshObligationAndFarms(args.signer),
-    postIxs: async (args) => [klendSdk.ixRefreshObligationAndFarms(args.signer)[2]],
-  }
-}
-
-async function makeJitoRestakingFlavor(
-  fetcher: ExponentFetcher,
-  jitoRestakingSyProgramId: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-): Promise<FlavorJitoRestaking> {
-  // TODO - I do not like hard-coding these magic numbers
-  const jitoVault = cpiAccounts.getSyState[1].pubkey
-
-  const jitoSdk = await JitoRestakingSySdk.load({
-    cnx: fetcher.connection,
-    jitoVault,
-    jitoRestakingSyProgramId,
-  })
-
-  return {
-    flavor: "jitoRestaking",
-    currentSyExchangeRate: Number(jitoSdk.state.syRate),
-    jitoSyState: jitoSdk.state,
-    emissions: jitoSdk.emissions.map((e) => ({
-      exchangeRate: e.index,
-      mint: e.mint,
-      tokenProgram: e.tokenProgram,
-    })),
-    mintBase: jitoSdk.mintBase,
-    baseTokenProgram: jitoSdk.tokenProgramBase,
-    ixMintSy: (args) => jitoSdk.ixMintSy(args),
-    ixRedeemSy: (args) => jitoSdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
-  }
-}
-
-async function makePerenaFlavor(
-  fetcher: ExponentFetcher,
-  perenaSyProgramId: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-): Promise<FlavorPerena> {
-  const perenaStablePool = cpiAccounts.getSyState[1].pubkey
-
-  const sySdk = await PerenaSySdk.load({
-    cnx: fetcher.connection,
-    perenaStablePool,
-    perenaSyProgramId,
-  })
-
-  return {
-    flavor: "perena",
-    currentSyExchangeRate: Number(sySdk.state.syRate),
-    mintBase: sySdk.mintBase,
-    baseTokenProgram: sySdk.tokenProgramBase,
-    ixMintSy: (args) => sySdk.ixMintSy(args),
-    ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
-    preIxs: async () => [],
-    postIxs: async () => [],
-    perenaSyState: sySdk.state,
-    emissions: sySdk.emissions.map((e) => ({
-      exchangeRate: e.index,
-      mint: e.mint,
-      tokenProgram: e.tokenProgram,
-    })),
-  }
-}
-
-async function makeGenericFlavor(
-  fetcher: ExponentFetcher,
-  genericStandardProgramId: PublicKey,
-  cpiAccounts: CpiAccountsRaw,
-  syConfig?: { skipWrap?: boolean },
-): Promise<FlavorGeneric> {
-  const genericSyMeta = cpiAccounts.depositSy[1].pubkey
-
-  const sySdk = await GenericSySdk.loadFromSyMeta({
-    cnx: fetcher.connection,
-    genericStandardProgramId,
-    syMetaAddress: genericSyMeta,
-    config: syConfig,
-  })
-  // @ts-ignore
-  const preIxs = []
-  // @ts-ignore
-  const postIxs = []
-
-  return {
-    flavor: "generic",
-    currentSyExchangeRate: sySdk.state.syRate,
-    mintBase: sySdk.state.account.yieldBearingMint,
-    baseTokenProgram: sySdk.tokenProgramBase,
-    ixMintSy: (args) => sySdk.ixMintSy(args),
-    ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
-    // @ts-ignore
-    preIxs: async () => preIxs,
-    // @ts-ignore
-    postIxs: async () => postIxs,
-    genericSyState: sySdk.state,
-    emissions: sySdk.emissions.map((e) => ({
-      exchangeRate: e.index,
-      mint: e.mint,
-      tokenProgram: e.tokenProgram,
-    })),
-  }
-}
-
-export function serializeFlavor(
-  flavor: Flavor,
-):
-  | FlavorMarginfiStateJson
-  | FlavorKaminoStateJson
-  | FlavorJitoRestakingStateJson
-  | FlavorPerenaStateJson
-  | FlavorGenericStateJson {
-  switch (flavor.flavor) {
-    case "marginfi":
-      return serializeFlavorMarginfi(flavor)
-    case "kamino":
-      return serializeFlavorKamino(flavor)
-    case "jitoRestaking":
-      return serializeFlavorJitoRestaking(flavor)
-    case "perena":
-      return serializeFlavorPerena(flavor)
-    case "generic":
-      return serializeFlavorGeneric(flavor)
-    default:
-      throw new Error(`Unsupported flavor for serialization: ${(flavor as any).flavor}`)
-  }
-}
-
-export function deserializeFlavor(
-  flavor:
-    | FlavorMarginfiStateJson
-    | FlavorKaminoStateJson
-    | FlavorJitoRestakingStateJson
-    | FlavorPerenaStateJson
-    | FlavorGenericStateJson,
-): Flavor {
-  switch (flavor.flavor) {
-    case "marginfi":
-      return makeFlavorMarginfiSync(deserializeFlavorMarginfi(flavor))
-    case "kamino":
-      return makeFlavorKaminoSync(deserializeFlavorKamino(flavor))
-    case "jitoRestaking":
-      return makeFlavorJitoRestakingSync(deserializeFlavorJitoRestaking(flavor))
-    case "perena":
-      return makeFlavorPerenaSync(deserializeFlavorPerena(flavor))
-    case "generic":
-      return makeFlavorGenericSync(deserializeFlavorGeneric(flavor))
-    default:
-      throw new Error(`Unsupported flavor for deserialization: ${(flavor as any).flavor}`)
-  }
-}