@exponent-labs/exponent-sdk 0.0.3

package/src/flavors.ts

@@ -0,0 +1,773 @@
+import { BN, web3 } from "@coral-xyz/anchor"
+import { ExponentFetcher, fetchKaminoReserve } from "@exponent-labs/exponent-fetcher"
+import { Environment } from "./environment"
+import { MfiSySdk } from "@exponent-labs/marginfi-sy-sdk"
+import { getMeta, KAMINO_LEND_PROGRAM_ID } from "@exponent-labs/kamino-lend-standard"
+import { KlendSySdk } from "@exponent-labs/kamino-sy-sdk"
+import {
+  FlavorKaminoStateJson,
+  FlavorKaminoState,
+  FlavorMarginfiState,
+  FlavorMarginfiStateJson,
+  FlavorKamino,
+  FlavorMarginfi,
+  FlavorDiscriminator,
+  MintSyArgs,
+  RedeemSyArgs,
+  Flavor,
+  CpiAccountsRaw,
+  FlavorJitoRestaking,
+  FlavorJitoRestakingState,
+  FlavorJitoRestakingStateJson,
+  FlavorPerena,
+  FlavorPerenaState,
+  FlavorPerenaStateJson,
+  FlavorGeneric,
+  FlavorGenericState,
+  InterfaceInstructionArgs,
+  FlavorGenericStateJson,
+} from "@exponent-labs/exponent-types"
+import { JitoRestakingSySdk } from "@exponent-labs/jito-restaking-sy-sdk"
+import { PreciseNumber } from "@exponent-labs/precise-number"
+import { PerenaSySdk } from "@exponent-labs/perena-sy-sdk"
+import { GenericSySdk } from "@exponent-labs/generic-sy-sdk"
+
+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 web3.PublicKey(flavor.mintBase),
+    baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
+    emissions: flavor.emissions.map((e) => ({
+      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      mint: new web3.PublicKey(e.mint),
+      tokenProgram: new web3.PublicKey(e.tokenProgram),
+    })),
+    bank: new web3.PublicKey(flavor.bank),
+    emissionMint: flavor.emissionMint ? new web3.PublicKey(flavor.emissionMint) : undefined,
+    emissionTokenProgram: flavor.emissionTokenProgram ? new web3.PublicKey(flavor.emissionTokenProgram) : undefined,
+    mfiSyState: {
+      selfAddress: new web3.PublicKey(flavor.mfiSyState.selfAddress),
+      marginfiSyProgramId: new web3.PublicKey(flavor.mfiSyState.marginfiSyProgramId),
+      syRate: flavor.mfiSyState.syRate,
+      mintBase: new web3.PublicKey(flavor.mfiSyState.mintBase),
+      tokenProgramBase: new web3.PublicKey(flavor.mfiSyState.tokenProgramBase),
+      marginfiProgramId: new web3.PublicKey(flavor.mfiSyState.marginfiProgramId),
+      marginfiGroupId: new web3.PublicKey(flavor.mfiSyState.marginfiGroupId),
+      emissionsMint: flavor.mfiSyState.emissionsMint ? new web3.PublicKey(flavor.mfiSyState.emissionsMint) : null,
+      emissionsTokenProgram: flavor.mfiSyState.emissionsTokenProgram
+        ? new web3.PublicKey(flavor.mfiSyState.emissionsTokenProgram)
+        : null,
+      account: {
+        marginfiBank: new web3.PublicKey(flavor.mfiSyState.account.marginfiBank),
+        marginfiAccount: new web3.PublicKey(flavor.mfiSyState.account.marginfiAccount),
+        mintSy: new web3.PublicKey(flavor.mfiSyState.account.mintSy),
+        tokenSyEscrow: new web3.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 web3.PublicKey(emission.mint),
+          tokenProgram: new web3.PublicKey(emission.tokenProgram),
+          escrowAccount: new web3.PublicKey(emission.escrowAccount),
+          index: { 0: [new BN(emission.index)] },
+          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          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(),
+      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 web3.PublicKey(flavor.mintBase),
+    baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
+    emissions: flavor.emissions.map((e) => ({
+      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      mint: new web3.PublicKey(e.mint),
+      tokenProgram: new web3.PublicKey(e.tokenProgram),
+    })),
+    kaminoSyState: {
+      selfAddress: new web3.PublicKey(flavor.kaminoSyState.selfAddress),
+      klendSyProgramId: new web3.PublicKey(flavor.kaminoSyState.klendSyProgramId),
+      syRate: flavor.kaminoSyState.syRate,
+      mintBase: new web3.PublicKey(flavor.kaminoSyState.mintBase),
+      tokenProgramBase: new web3.PublicKey(flavor.kaminoSyState.tokenProgramBase),
+      klendProgramId: new web3.PublicKey(flavor.kaminoSyState.klendProgramId),
+      klendMarketId: new web3.PublicKey(flavor.kaminoSyState.klendMarketId),
+      account: {
+        kaminoReserve: new web3.PublicKey(flavor.kaminoSyState.account.kaminoReserve),
+        kaminoObligation: new web3.PublicKey(flavor.kaminoSyState.account.kaminoObligation),
+        kaminoFarm: new web3.PublicKey(flavor.kaminoSyState.account.kaminoFarm),
+        kaminoUserMetadata: new web3.PublicKey(flavor.kaminoSyState.account.kaminoUserMetadata),
+        mintSy: new web3.PublicKey(flavor.kaminoSyState.account.mintSy),
+        tokenSyEscrow: new web3.PublicKey(flavor.kaminoSyState.account.tokenSyEscrow),
+        minMintSize: flavor.kaminoSyState.account.minMintSize,
+        minRedeemSize: flavor.kaminoSyState.account.minRedeemSize,
+        userState: new web3.PublicKey(flavor.kaminoSyState.account.userState),
+        maxSySupply: flavor.kaminoSyState.account.maxSySupply,
+        emissions: flavor.kaminoSyState.account.emissions.map((emission) => ({
+          mint: new web3.PublicKey(emission.mint),
+          tokenProgram: new web3.PublicKey(emission.tokenProgram),
+          escrowAccount: new web3.PublicKey(emission.escrowAccount),
+          index: { 0: [new BN(emission.index)] },
+          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          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 web3.PublicKey(flavor.mintBase),
+    baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
+    emissions: flavor.emissions.map((e) => ({
+      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      mint: new web3.PublicKey(e.mint),
+      tokenProgram: new web3.PublicKey(e.tokenProgram),
+    })),
+    jitoSyState: {
+      selfAddress: new web3.PublicKey(flavor.jitoSyState.selfAddress),
+      syRate: flavor.jitoSyState.syRate,
+      underlyingExchangeRate: flavor.jitoSyState.underlyingExchangeRate,
+      mintBase: new web3.PublicKey(flavor.jitoSyState.mintBase),
+      tokenProgramBase: new web3.PublicKey(flavor.jitoSyState.tokenProgramBase),
+      account: {
+        jitoVault: new web3.PublicKey(flavor.jitoSyState.account.jitoVault),
+        mintSy: new web3.PublicKey(flavor.jitoSyState.account.mintSy),
+        tokenSyEscrow: new web3.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 web3.PublicKey(a)),
+        interfaceType: flavor.jitoSyState.account.interfaceType,
+        emissions: flavor.jitoSyState.account.emissions.map((emission) => ({
+          mint: new web3.PublicKey(emission.mint),
+          tokenProgram: new web3.PublicKey(emission.tokenProgram),
+          escrowAccount: new web3.PublicKey(emission.escrowAccount),
+          index: { 0: [new BN(emission.index)] },
+          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
+          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
+          treasuryEmission: new BN(emission.treasuryEmission),
+        })),
+      },
+    },
+  }
+}
+
+export function serializeFlavorParena(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(),
+      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: {
+          ...flavor.genericSyState.account.hook,
+          preMintHookDiscriminator: Buffer.from(flavor.genericSyState.account.hook.preMintHookDiscriminator),
+          postRedeemHookDiscriminator: Buffer.from(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: flavor.genericSyState.account.interfaceType,
+        index: parseFloat(PreciseNumber.fromRaw(flavor.genericSyState.account.index[0]).valueString),
+      },
+    },
+  }
+}
+
+export function deserializeFlavorParena(flavor: FlavorPerenaStateJson): FlavorPerenaState {
+  return {
+    flavor: "perena",
+    currentSyExchangeRate: flavor.currentSyExchangeRate,
+    baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
+    mintBase: new web3.PublicKey(flavor.mintBase),
+    perenaSyState: {
+      selfAddress: new web3.PublicKey(flavor.perenaSyState.selfAddress),
+      syRate: flavor.perenaSyState.syRate,
+      account: {
+        perenaStablePool: new web3.PublicKey(flavor.perenaSyState.account.perenaStablePool),
+        mintSy: new web3.PublicKey(flavor.perenaSyState.account.mintSy),
+        tokenSyEscrow: new web3.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 web3.PublicKey(emission.mint),
+          tokenProgram: new web3.PublicKey(emission.tokenProgram),
+          escrowAccount: new web3.PublicKey(emission.escrowAccount),
+          index: { 0: [new BN(emission.index)] },
+          lastSeenIndex: { 0: [new BN(emission.lastSeenIndex)] },
+          lastSeenTotalAccruedEmissions: new BN(emission.lastSeenTotalAccruedEmissions),
+          totalClaimedEmissions: new BN(emission.totalClaimedEmissions),
+          treasuryEmission: new BN(emission.treasuryEmission),
+        })),
+        interfaceAccounts: flavor.perenaSyState.account.interfaceAccounts.map((a) => new web3.PublicKey(a)),
+      },
+      lpMint: new web3.PublicKey(flavor.perenaSyState.mintBase),
+      tokenProgramBase: new web3.PublicKey(flavor.perenaSyState.tokenProgramBase),
+    },
+    emissions: flavor.emissions.map((e) => ({
+      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      mint: new web3.PublicKey(e.mint),
+      tokenProgram: new web3.PublicKey(e.tokenProgram),
+    })),
+  }
+}
+
+export function deserializeFlavorGeneric(flavor: FlavorGenericStateJson): FlavorGenericState {
+  return {
+    flavor: "generic",
+    currentSyExchangeRate: flavor.currentSyExchangeRate,
+    mintBase: new web3.PublicKey(flavor.mintBase),
+    baseTokenProgram: new web3.PublicKey(flavor.baseTokenProgram),
+    emissions: flavor.emissions.map((e) => ({
+      exchangeRate: { 0: [new BN(PreciseNumber.fromRaw([new BN(e.exchangeRate)]).valueString)] },
+      mint: new web3.PublicKey(e.mint),
+      tokenProgram: new web3.PublicKey(e.tokenProgram),
+    })),
+    genericSyState: {
+      selfAddress: new web3.PublicKey(flavor.genericSyState.selfAddress),
+      syRate: flavor.genericSyState.syRate,
+      tokenProgramBase: new web3.PublicKey(flavor.genericSyState.tokenProgramBase),
+      account: {
+        mintSy: new web3.PublicKey(flavor.genericSyState.account.mintSy),
+        yieldBearingMint: new web3.PublicKey(flavor.genericSyState.account.yieldBearingMint),
+        tokenSyEscrow: new web3.PublicKey(flavor.genericSyState.account.tokenSyEscrow),
+        interfaceAccounts: flavor.genericSyState.account.interfaceAccounts.map((a) => new web3.PublicKey(a)),
+        interfaceType: 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 web3.PublicKey(flavor.genericSyState.account.hook.programId),
+        },
+        emissions: flavor.genericSyState.account.emissions.map((e) => ({
+          mint: new web3.PublicKey(e.mint),
+          tokenProgram: new web3.PublicKey(e.tokenProgram),
+          escrowAccount: new web3.PublicKey(e.escrowAccount),
+          index: { 0: [new BN(e.index)] },
+          lastSeenIndex: { 0: [new BN(e.lastSeenIndex)] },
+          lastSeenTotalAccruedEmissions: new BN(e.lastSeenTotalAccruedEmissions),
+          totalClaimedEmissions: new BN(e.totalClaimedEmissions),
+          treasuryEmission: new BN(e.treasuryEmission),
+        })),
+        index: { 0: [new BN(flavor.genericSyState.account.index)] },
+      },
+    },
+  }
+}
+
+/** 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 (args) => [],
+    postIxs: async (args) => [],
+  }
+}
+
+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 (args) => [],
+    postIxs: async (args) => [],
+  }
+}
+
+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): FlavorGeneric {
+  const sySdk = new GenericSySdk(data.genericSyState)
+  return {
+    ...data,
+    flavor: "generic",
+    ixMintSy: (args) => sySdk.ixMintSy(args),
+    ixRedeemSy: (args) => sySdk.ixRedeemSy(args),
+    preIxs: async () => [],
+    postIxs: async () => [],
+  }
+}
+
+export function flavorFinder(env: Environment, syProgram: web3.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: web3.PublicKey,
+  cpiAccounts: CpiAccountsRaw,
+): 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)
+  }
+  {
+    throw new Error("Unknown flavor")
+  }
+}
+
+async function makeMarginfiFlavor(
+  fetcher: ExponentFetcher,
+  marginfiSyProgramId: web3.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: web3.PublicKey) => x.equals(marginfiSyProgramId)
+  const mapOptAccount = (x: web3.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 (args) => [],
+    postIxs: async (args) => [],
+  }
+}
+
+async function makeKaminoFlavor(
+  fetcher: ExponentFetcher,
+  kaminoSyProgramId: web3.PublicKey,
+  cpiAccounts: CpiAccountsRaw,
+): Promise<FlavorKamino> {
+  const isNone = (x: web3.PublicKey) => x.equals(kaminoSyProgramId)
+  const mapOptAccount = (x: web3.PublicKey) => (isNone(x) ? undefined : x)
+
+  // 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
+  const baseTokenProgram = await fetcher.connection.getAccountInfo(mintBase).then((a) => a.owner)
+
+  const meta = getMeta(reserve, kaminoSyProgramId)
+
+  const syMeta = await fetcher.fetchKaminoSyMeta(meta)
+
+  const klendSdk = await KlendSySdk.load({
+    cnx: fetcher.connection,
+    klendMarketId: reserveAcct.lendingMarket,
+    klendReserve: reserve,
+    klendSyProgramId: kaminoSyProgramId,
+    klendProgramId: KAMINO_LEND_PROGRAM_ID,
+  })
+
+  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: web3.PublicKey,
+  cpiAccounts: CpiAccountsRaw,
+): Promise<FlavorJitoRestaking> {
+  // TODO - I do not like hard-coding these magic numbers
+  const jitoVault = cpiAccounts.getSyState[1].pubkey
+  // const recentBlockhash = await fetcher.connection.getLatestBlockhash().then((b) => b.blockhash)
+
+  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: web3.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: web3.PublicKey,
+  cpiAccounts: CpiAccountsRaw,
+): Promise<FlavorGeneric> {
+  const genericSyMeta = cpiAccounts.depositSy[1].pubkey
+
+  const sySdk = await GenericSySdk.loadFromSyMeta({
+    cnx: fetcher.connection,
+    genericStandardProgramId,
+    syMetaAddress: genericSyMeta,
+  })
+
+  let preIxs = []
+  let postIxs = []
+
+  const isFragmetric = "fragmetric" in sySdk.state.account.interfaceType
+
+  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),
+    preIxs: async () => preIxs,
+    postIxs: async () => postIxs,
+    genericSyState: sySdk.state,
+    emissions: sySdk.emissions.map((e) => ({
+      exchangeRate: e.index,
+      mint: e.mint,
+      tokenProgram: e.tokenProgram,
+    })),
+  }
+}