hedge-web3 0.1.13 → 0.1.14

package/src/instructions/redeemVault.ts

@@ -1,17 +1,18 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+// import { TokenInstructions } from '@project-serum/serum'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function redeemVault (
   program: Program,
   provider: Provider,
   payer: Signer,
   vaultPublicKey: PublicKey,
-  repayAmount: number,
+  redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -22,15 +23,35 @@ export async function redeemVault (
   // Prep the user to get USDH back out at some point
   const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
 
+  const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
+  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
+  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
+  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint)
+
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint)
+
+  const token = new Token(
+    provider.connection,
+    collateralStateAccountInfo.collateralMint,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  const payerTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
   const history = Keypair.generate()
   const transaction = new Transaction().add(
     await redeemVaultInstruction(
       program,
       payer.publicKey,
       payerUsdhAccount.address,
+      payerTokenAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount,
       history.publicKey,
-      repayAmount,
+      collateralStateAccountPublicKey,
+      collateralAssociatedTokenAccount,
+      redeemAmount,
       transactionOverrideTime
     )
   )
@@ -41,37 +62,42 @@ export async function redeemVault (
 export async function redeemVaultInstruction (
   program: Program,
   payerPublicKey: PublicKey,
-  ownerUsdhAccount: PublicKey,
+  payerUsdhAccount: PublicKey,
+  destinationTokenAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
-  repayAmount: number,
+  collateralStateAccount: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
+  redeemAmount: number,
   transactionOverrideTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
   const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
   )
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   return program.instruction.redeemVault(
-    new BN(repayAmount),
+    new BN(redeemAmount),
     new BN(transactionOverrideTime ?? (Date.now() / 1000)), // override start time
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
         collateralStateAccount: collateralStateAccount,
-        vaultAccount: vaultPublickey,
+        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vault: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
         feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         usdhMint: usdhMintPublickey,
         payer: payerPublicKey,
-        payerUsdhAccount: ownerUsdhAccount,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        payerUsdhAccount: payerUsdhAccount,
+        destinationTokenAccount: destinationTokenAccount,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/refreshOraclePrice.ts

@@ -6,6 +6,7 @@ export async function refreshOraclePrice (
   program: Program,
   provider: Provider,
   payer: Signer,
+  collateralType: string,
   network: Cluster,
   overridePrice?: number,
   overrideTime?: number
@@ -13,6 +14,7 @@ export async function refreshOraclePrice (
   const transaction = new Transaction().add(
     await refreshOraclePriceInstruction(
       program,
+      collateralType,
       network,
       overridePrice,
       overrideTime
@@ -23,13 +25,14 @@ export async function refreshOraclePrice (
 
 export async function refreshOraclePriceInstruction (
   program: Program,
+  collateralType: string,
   network: Cluster,
   overridePrice?: number,
   overrideTime?: number
 ): Promise<TransactionInstruction> {
   const enc = new TextEncoder()
-  const [oracleInfoAccount] = await PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
-  const [collateralStateAccount] = await PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY)
+  const [oracleInfoAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
+  const [collateralStateAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY)
 
   return program.instruction.refreshOraclePrice(
     new BN(overridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price

package/src/instructions/repayVault.ts

@@ -1,7 +1,7 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function repayVault (
   program: Program,
@@ -10,7 +10,7 @@ export async function repayVault (
   vaultPublicKey: PublicKey,
   repayAmount: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -20,6 +20,12 @@ export async function repayVault (
 
   // Prep the user to get USDH back out at some point
   const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+  const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
+
+  const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
+  const collateralStateAccount = await program.account.collateralState.fetch(collateralStateAccountPublicKey)
+  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccount.collateralMint)
+  const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccount.collateralMint)
 
   const history = Keypair.generate()
   const transaction = new Transaction().add(
@@ -28,7 +34,10 @@ export async function repayVault (
       payer.publicKey,
       payerUsdhAccount.address,
       vaultPublicKey,
+      vaultAssociatedTokenAccount,
       history.publicKey,
+      collateralStateAccountPublicKey,
+      collateralAssociatedTokenAccount,
       repayAmount
     )
   )
@@ -41,34 +50,37 @@ export async function repayVaultInstruction (
   payerPublicKey: PublicKey,
   ownerUsdhAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
+  collateralStateAccount: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
   repayAmount: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
   const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
     hedgeStakingPoolPublicKey,
     usdhMintPublickey
   )
 
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
-
   return program.instruction.repayVault(
     new BN(repayAmount),
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
         collateralStateAccount: collateralStateAccount,
+        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
         vaultAccount: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
         history: historyPublicKey,
         feePool: hedgeStakingPoolPublicKey,
         feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
         usdhMint: usdhMintPublickey,
         vaultOwner: payerPublicKey,
         ownerUsdhAccount: ownerUsdhAccount,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/withdrawStakingPool.ts

@@ -33,16 +33,16 @@ export async function withdrawStakingPoolInstruction (
   stakedTokenMintPublicKey: PublicKey,
   overrideStartTime?: number
 ): Promise<TransactionInstruction> {
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
-  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
+  const hedgeMintPublickey = await getHedgeMintPublicKey()
   const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey)
   const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey)
   const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey)
   const payerAssociatedStakedTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey)
   const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payerPublicKey, hedgeMintPublickey)
   const payerAssociatedUsdhAccount = await findAssociatedTokenAddress(payerPublicKey, usdhMintPublickey)
-  const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey,hedgeMintPublickey)
+  const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMintPublickey)
 
   return program.instruction.withdrawStakingPool(
     new BN(overrideStartTime ?? Date.now() / 1000), // override current time
@@ -62,8 +62,8 @@ export async function withdrawStakingPoolInstruction (
         stakedTokenMint: stakedTokenMintPublicKey,
         usdhMint: usdhMintPublickey,
         rent: SYSVAR_RENT_PUBKEY,
-        splTokenProgramInfo: TOKEN_PROGRAM_ID,
-        splAssociatedTokenProgramInfo: ASSOCIATED_TOKEN_PROGRAM_ID,
+        tokenProgram: TOKEN_PROGRAM_ID,
+        associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/instructions/withdrawVault.ts

@@ -1,7 +1,8 @@
 import { BN, Program, Provider } from '@project-serum/anchor'
 import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { TokenInstructions } from '@project-serum/serum'
 import { Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
-import { getSolCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+import { findAssociatedTokenAddress, getCollateralStateAccountPublicKey, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
 
 export async function withdrawVault (
   program: Program,
@@ -10,7 +11,7 @@ export async function withdrawVault (
   vaultPublicKey: PublicKey,
   withdrawAmount: number
 ): Promise<PublicKey> {
-  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const usdhMintPublickey = await getUsdhMintPublicKey()
   const USDH = new Token(
     provider.connection,
     usdhMintPublickey,
@@ -22,13 +23,28 @@ export async function withdrawVault (
   await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
 
   const history = Keypair.generate()
-  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey()
+
+  const vaultAccount = await program.account.vault.fetch(vaultPublicKey)
+  const collateralStateAccount = await getCollateralStateAccountPublicKey(vaultAccount.collateralType)
+  const vaultAssociatedCollateralAccount = await findAssociatedTokenAddress(vaultPublicKey, TokenInstructions.WRAPPED_SOL_MINT)
+  const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccount)
+  const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccount, collateralStateAccountInfo.collateralMint)
+
+  const token = new Token(provider.connection, collateralStateAccountInfo.collateralMint, TOKEN_PROGRAM_ID, payer)
+
+  const destinationTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
   const transaction = new Transaction().add(
     await withdrawVaultInstruction(
       program,
       vaultSystemStatePublicKey,
       payer.publicKey,
+      destinationTokenAccount.address,
       vaultPublicKey,
+      vaultAssociatedCollateralAccount,
+      collateralStateAccount,
+      collateralAssociatedTokenAccount,
       history.publicKey,
       withdrawAmount
     )
@@ -41,20 +57,27 @@ export async function withdrawVaultInstruction (
   program: Program,
   vaultSystemStatePublicKey: PublicKey,
   payerPublicKey: PublicKey,
+  destinationTokenAccount: PublicKey,
   vaultPublickey: PublicKey,
+  vaultAssociatedCollateralPublicKey: PublicKey,
+  collateralStateAccount: PublicKey,
+  collateralAssociatedTokenAccount: PublicKey,
   historyPublicKey: PublicKey,
   withdrawAmount: number
 ): Promise<TransactionInstruction> {
-  const collateralStateAccount = await getSolCollateralStateAccountPublicKey()
   return program.instruction.withdrawVault(
     new BN(withdrawAmount),
     {
       accounts: {
         vaultSystemState: vaultSystemStatePublicKey,
         collateralStateAccount: collateralStateAccount,
-        vaultAccount: vaultPublickey,
+        collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+        vault: vaultPublickey,
+        vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
         history: historyPublicKey,
         vaultOwner: payerPublicKey,
+        destinationTokenAccount: destinationTokenAccount,
+        tokenProgram: TOKEN_PROGRAM_ID,
         systemProgram: SystemProgram.programId
       },
       signers: []

package/src/state/LiquidationPoolEra.ts

@@ -8,22 +8,16 @@ import { DecimalFromU128 } from '../HedgeDecimal'
  */
 export class LiquidationPoolEra {
   public totalDeposits: number
-
   public product: Decimal
-
-  public sum: Decimal
-
+  public sum: [Decimal]
   public hedgeRewardsAccumulator: Decimal
-
   public hedgeRewardsTimestamp: number
 
   constructor (public liquidyPoolEra: any) {
     this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber()
-
     this.product = DecimalFromU128(liquidyPoolEra.productBytes)
-    this.sum = DecimalFromU128(liquidyPoolEra.sumBytes)
+    this.sum = liquidyPoolEra.sumBytes.map((sumBytes: number) => { return DecimalFromU128(sumBytes) })
     this.hedgeRewardsAccumulator = DecimalFromU128(liquidyPoolEra.hedgeRewardsAccumulatorBytes)
-
     this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber()
   }
 }

package/src/state/LiquidationPosition.ts

@@ -1,4 +1,4 @@
-import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
+import { PublicKey } from '@solana/web3.js'
 import Decimal from 'decimal.js'
 import { DecimalFromU128 } from '../HedgeDecimal'
 import { LiquidationPoolEra } from './LiquidationPoolEra'
@@ -7,71 +7,70 @@ import { LiquidationPoolState } from './LiquidationPoolState'
 export class LiquidationPosition {
   public publicKey: PublicKey
   public eraPublicKey: PublicKey
-  public era: LiquidationPoolEra
-  public liquidationPoolState: LiquidationPoolState
+  public liquidationPoolState?: LiquidationPoolState
 
   public ownerAccount: PublicKey
   public deposit: number
   public closedUsdh: number
-  public closedSol: number
   public timestampOpened: Date
   public timestampClosed: Date
 
-  public productSnapshot: Decimal
-  public sumSnapshot: Decimal
+  public productSnapshotEntry: Decimal
+  public productSnapshotClosed: Decimal
+  public sumSnapshotsEntry: [Decimal]
+  public sumSnapshotsClosed: [Decimal]
   public hedgeRewardsSnapshot: Decimal
   public open: boolean
 
-  constructor (poolPositionInfo: any, key: PublicKey, era: LiquidationPoolEra, liquidationPoolState: LiquidationPoolState) {
+  constructor (poolPositionInfo: any, key: PublicKey) {
     this.publicKey = key
     this.eraPublicKey = poolPositionInfo.era
-    this.era = era
-    this.liquidationPoolState = liquidationPoolState
     this.ownerAccount = poolPositionInfo.ownerAccount
     this.deposit = poolPositionInfo.deposit.toNumber()
     this.closedUsdh = poolPositionInfo.closedUsdh.toNumber()
-    this.closedSol = poolPositionInfo.closedSol.toNumber()
     this.timestampOpened = poolPositionInfo.timestampOpened.toNumber()
     this.timestampClosed = poolPositionInfo.timestampClosed.toNumber()
 
-    this.productSnapshot = DecimalFromU128(poolPositionInfo.productSnapshotBytes)
-    this.sumSnapshot = DecimalFromU128(poolPositionInfo.sumSnapshotBytes)
+    this.productSnapshotEntry = DecimalFromU128(poolPositionInfo.productSnapshotEntry)
+    this.productSnapshotClosed = DecimalFromU128(poolPositionInfo.productSnapshotClosed)
+    this.sumSnapshotsEntry = poolPositionInfo.sumSnapshotsEntry.map((sum: any) => { return DecimalFromU128(sum) })
+    this.sumSnapshotsClosed = poolPositionInfo.sumSnapshotsClosed.map((sum: any) => { return DecimalFromU128(sum) })
     this.hedgeRewardsSnapshot = DecimalFromU128(poolPositionInfo.hedgeRewardsSnapshotAccum)
     this.open = poolPositionInfo.state.open !== undefined
   }
 
-  public getUsdhAvailable (): Decimal {
-    return (this.era.product.div(this.productSnapshot)).mul(new Decimal(this.deposit))
+  public getUsdhAvailable (era: LiquidationPoolEra): Decimal {
+    return (era.product.div(this.productSnapshotEntry)).mul(new Decimal(this.deposit))
   }
 
-  public getSolAvailable (): Decimal {
-    return this.era.sum.minus(this.sumSnapshot).div(this.productSnapshot).mul(new Decimal(this.deposit)).floor()
+  public getSolAvailable (era: LiquidationPoolEra): Decimal {
+    return era.sum[0].minus(this.sumSnapshotsEntry[0]).div(this.productSnapshotEntry).mul(new Decimal(this.deposit)).floor()
   }
 
-  public getHedgeAvailable (): Decimal {
-    const LiquidationPoolTotalSupply = 2000000.0 * LAMPORTS_PER_SOL
-    const hedgeRewardsSinceLastUpdate = hedgeRewardsDecay(
-      LiquidationPoolTotalSupply,
-      this.liquidationPoolState.hedgeInitRewardsTimestamp * 1000,
-      this.era.hedgeRewardsTimestamp * 1000,
-      Date.now(),
-      365 * 1000)
+  // public getHedgeAvailable (): Decimal {
+  //   const LiquidationPoolTotalSupply = 2000000.0 * LAMPORTS_PER_SOL
+  //   const hedgeRewardsSinceLastUpdate = hedgeRewardsDecay(
+  //     LiquidationPoolTotalSupply,
+  //     this.liquidationPoolState.hedgeInitRewardsTimestamp * 1000,
+  //     this.era.hedgeRewardsTimestamp * 1000,
+  //     Date.now(),
+  //     365 * 1000)
 
-    if (this.era.totalDeposits === 0) {
-      return new Decimal(0)
-    }
+  //   if (this.era.totalDeposits === 0) {
+  //     return new Decimal(0)
+  //   }
 
-    const rewardsPerToken = this.era.product.mul(new Decimal(hedgeRewardsSinceLastUpdate / this.era.totalDeposits))
-    const newAccumulator = rewardsPerToken.add(new Decimal(this.era.hedgeRewardsAccumulator))
-    const hedgeAvailable = (newAccumulator.minus(this.hedgeRewardsSnapshot)).mul(new Decimal(this.deposit)).div(new Decimal(this.productSnapshot))
-    return hedgeAvailable
-  }
+  //   const rewardsPerToken = this.era.product.mul(new Decimal(hedgeRewardsSinceLastUpdate / this.era.totalDeposits))
+  //   const newAccumulator = rewardsPerToken.add(new Decimal(this.era.hedgeRewardsAccumulator))
+  //   const hedgeAvailable = (newAccumulator.minus(this.hedgeRewardsSnapshot)).mul(new Decimal(this.deposit)).div(new Decimal(this.productSnapshot))
+  //   return hedgeAvailable
+  // }
 }
 
-function hedgeRewardsDecay (supply: number, birthTime: number, timeIn: number, timeOut: number, halfLifeInDays: number): number {
-  const timeInOffsetStart = timeIn - birthTime
-  const timeOutOffsetStart = timeOut - birthTime
-  const halfLife = -1 * Math.log(2) / (halfLifeInDays * 60 * 60 * 24)
-  const awardedTokens = supply * (Math.pow(Math.E, halfLife * timeInOffsetStart) - Math.pow(Math.E, halfLife * timeOutOffsetStart))
-  return awardedTokens
-}
+// function hedgeRewardsDecay (supply: number, birthTime: number, timeIn: number, timeOut: number, halfLifeInDays: number): number {
+//   const timeInOffsetStart = timeIn - birthTime
+//   const timeOutOffsetStart = timeOut - birthTime
+//   const halfLife = -1 * Math.log(2) / (halfLifeInDays * 60 * 60 * 24)
+//   const awardedTokens = supply * (Math.pow(Math.E, halfLife * timeInOffsetStart) - Math.pow(Math.E, halfLife * timeOutOffsetStart))
+//   return awardedTokens
+// }