hedge-web3 0.1.1 → 0.1.6

package/src/instructions/withdrawVault.ts

@@ -0,0 +1,65 @@
+import { BN, Program, Provider } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, getUsdhMintPublicKey, getVaultSystemStatePublicKey } from '../Constants'
+
+export async function withdrawVault (
+  program: Program,
+  provider: Provider,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  withdrawAmount: number,
+  chainlinkOverridePrice?: number
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    provider.connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const transaction = new Transaction().add(
+    withdrawVaultInstruction(
+      program,
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      vaultPublicKey,
+      history.publicKey,
+      withdrawAmount,
+      chainlinkOverridePrice
+    )
+  )
+  await sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts)
+  return vaultPublicKey
+}
+
+export function withdrawVaultInstruction (
+  program: Program,
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  withdrawAmount: number,
+  chainlinkOverridePrice?: number
+): TransactionInstruction {
+  return program.instruction.withdrawVault(
+    new BN(withdrawAmount),
+    new BN(chainlinkOverridePrice ?? 200 * LAMPORTS_PER_SOL),
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        vaultOwner: payerPublicKey,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/state/LiquidationPoolEra.ts

@@ -0,0 +1,29 @@
+
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+
+/**
+ * Represents an on-chian pool era. In the event an era is depleted of deposits, a new era is
+ * created to maintain each users contribution to the pool.
+ */
+export class LiquidationPoolEra {
+  public totalDeposits: number
+
+  public product: 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.hedgeRewardsAccumulator = DecimalFromU128(liquidyPoolEra.hedgeRewardsAccumulatorBytes)
+
+    this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber()
+  }
+}

package/src/state/LiquidationPoolState.ts

@@ -0,0 +1,10 @@
+
+export class LiquidationPoolState {
+  public lifetimeDeposits: number
+  public hedgeInitRewardsTimestamp: number
+  constructor (public liquidationPoolState: any) {
+    this.lifetimeDeposits = liquidationPoolState.lifetimeDeposits.toNumber()
+    this.hedgeInitRewardsTimestamp = liquidationPoolState.hedgeInitRewardsTimestamp.toNumber()
+    // TODO Add the rest that are missing. Do we need them?
+  }
+}

package/src/state/LiquidationPosition.ts

@@ -0,0 +1,77 @@
+import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+import { LiquidationPoolEra } from './LiquidationPoolEra'
+import { LiquidationPoolState } from './LiquidationPoolState'
+
+export class LiquidationPosition {
+  public publicKey: PublicKey
+  public eraPublicKey: PublicKey
+  public era: LiquidationPoolEra
+  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 hedgeRewardsSnapshot: Decimal
+  public open: boolean
+
+  constructor (poolPositionInfo: any, key: PublicKey, era: LiquidationPoolEra, liquidationPoolState: LiquidationPoolState) {
+    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.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 getSolAvailable (): Decimal {
+    return this.era.sum.minus(this.sumSnapshot).div(this.productSnapshot).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)
+
+    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
+  }
+}
+
+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
+}

package/src/state/StakingPool.ts

@@ -0,0 +1,38 @@
+
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+
+export class StakingPool {
+  public publicKey: PublicKey
+  public deposits: number
+  lastTransactionTime: number
+  startTime: number
+  halfLifeInDays: number
+  totalHedgeReward: number
+
+  hedgeRewardAccumulator: Decimal
+  usdhFeeAccumulator: Decimal
+  solFeeAccumulator: Decimal
+
+  constructor (public poolInfo: any, publicKey: PublicKey) {
+    this.publicKey = publicKey
+    this.deposits = poolInfo.deposits.toNumber()
+    // this.totalFeesNow = poolInfo.totalFeesNow.toNumber()
+    // this.totalFeesPrevious = poolInfo.totalFeesPrevious.toNumber()
+    this.lastTransactionTime = poolInfo.lastTransactionTime.toNumber()
+    this.startTime = poolInfo.startTime.toNumber()
+    this.halfLifeInDays = poolInfo.halfLifeInDays.toNumber()
+    this.totalHedgeReward = poolInfo.totalHedgeReward.toNumber()
+
+    this.hedgeRewardAccumulator = DecimalFromU128(poolInfo.hedgeRewardAccumulator)
+    this.usdhFeeAccumulator = DecimalFromU128(poolInfo.usdhFeeAccumulator)
+    this.solFeeAccumulator = DecimalFromU128(poolInfo.solFeeAccumulator)
+    // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
+  }
+
+//   updateFeeAccumulator () {
+//     this.feeAccumulator = (this.totalFeesNow - this.totalFeesPrevious) / this.deposits
+//     this.totalFeesPrevious = this.totalFeesNow
+//   }
+}

package/src/state/StakingPoolPosition.ts

@@ -0,0 +1,39 @@
+
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+import { StakingPool } from './StakingPool'
+
+export class StakingPoolPosition {
+  public publicKey: PublicKey
+  public pool: StakingPool
+  public owner: PublicKey
+  public deposited: number
+  public timestampOpened: number
+  public timestampClosed: number
+  public closedRewardedTokens: number
+  public startHedgeRewardAccumulator: Decimal
+  public startUsdhFeeAccumulator: Decimal
+  public startSolFeeAccumulator: Decimal
+  public open: boolean
+
+  constructor (public poolPositionInfo: any, key: PublicKey, stakingPool: StakingPool) {
+    this.publicKey = key
+    this.pool = stakingPool
+    this.owner = poolPositionInfo.owner
+    this.deposited = poolPositionInfo.deposited.toNumber()
+    this.timestampOpened = poolPositionInfo.timestampOpened.toNumber()
+    this.timestampClosed = poolPositionInfo.timestampClosed.toNumber()
+    this.closedRewardedTokens = poolPositionInfo.closedRewardedTokens.toNumber()
+
+    this.startHedgeRewardAccumulator = DecimalFromU128(poolPositionInfo.startHedgeRewardAccumulator)
+    this.startUsdhFeeAccumulator = DecimalFromU128(poolPositionInfo.startUsdhFeeAccumulator)
+    this.startSolFeeAccumulator = DecimalFromU128(poolPositionInfo.startSolFeeAccumulator)
+
+    this.open = poolPositionInfo.state.open !== undefined
+  }
+
+  public getCurrentUsdhFeeReward (): Decimal {
+    return this.pool.usdhFeeAccumulator.minus(this.startUsdhFeeAccumulator).times(new Decimal(this.deposited))
+  }
+}

package/src/{accounts → state}/VaultAccount.ts

@@ -1,5 +1,6 @@
 import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
-import { HedgeDecimal } from '../HedgeDecimal'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
 
 /**
  * A class that represents an on-chian vault.
@@ -18,7 +19,7 @@ export class VaultAccount {
   deposited: number
 
   /** The minimum collateral ratio this vault must maintain to not be subject to liquidation. */
-  minCollateralRatio: HedgeDecimal
+  minCollateralRatio: Decimal
 
   /** The SOL/USD price at which this vault is subject to liquidation */
   liquidationPrice: number
@@ -26,15 +27,13 @@ export class VaultAccount {
   /** Current State of the vautl ("Open", "Closed", "Liquidated") */
   vaultStatus: string
 
-  constructor (vault: any
-    , publicKey: PublicKey) {
+  constructor (vault: any, publicKey: PublicKey) {
     this.publicKey = publicKey
     this.vaultOwner = vault.vaultOwner
     this.debt = vault.debt.toNumber()
     this.deposited = vault.deposited.toNumber()
-    this.minCollateralRatio = vault.minCollateralRatio.toNumber()
+    this.minCollateralRatio = DecimalFromU128(vault.minCollateralRatio)
     this.liquidationPrice = vault.liquidationPrice.toNumber()
-    this.minCollateralRatio = vault.minCollateralRatio.toNumber()
     this.vaultStatus = Object.keys(vault.vaultStatus)[0]
   }
 

package/src/state/VaultHistoryEvent.ts

@@ -0,0 +1,61 @@
+
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '../HedgeDecimal'
+
+export class VaultHistoryEvent {
+  publicKey: PublicKey
+  actorAccount: PublicKey
+  usdSolPrice: Decimal
+  usdhDebtBefore: number
+  usdhDebtAfter: number
+  solBalanceBefore: number
+  solBalanceAfter: number
+  minCollateralRatioBefore: Decimal
+  minCollateralRatioAfter: Decimal
+  vaultStateBefore: PublicKey
+  vaultStateAfter: PublicKey
+  timestamp: PublicKey
+  action: VaultHistoryAction
+
+  constructor (public account: any, publicKey: PublicKey) {
+    this.publicKey = publicKey
+    this.actorAccount = account.actorAccount
+
+    this.usdSolPrice = DecimalFromU128(account.usdSolPrice.toString())
+
+    this.usdhDebtBefore = account.usdhDebtBefore.toNumber()
+    this.usdhDebtAfter = account.usdhDebtAfter.toNumber()
+    this.solBalanceBefore = account.solBalanceBefore.toNumber()
+    this.solBalanceAfter = account.solBalanceAfter.toNumber()
+    this.minCollateralRatioBefore = DecimalFromU128(account.minCollateralRatioBefore)
+    this.minCollateralRatioAfter = DecimalFromU128(account.minCollateralRatioAfter)
+    this.vaultStateBefore = account.vaultStateBefore
+    this.vaultStateAfter = account.vaultStateAfter
+
+    this.timestamp = account.timestamp.toNumber()
+    this.action = account.action
+  }
+}
+
+export enum VaultStatus {
+  Open,
+  Closed,
+  Liquidated,
+  Distributed,
+  Redeemed,
+}
+
+export enum VaultHistoryAction {
+  Create,
+  Close,
+  Liquidate,
+  PartialLiquidate,
+  Distributed,
+  Redeem,
+  TransferOwnership,
+  Deposit,
+  Withdraw,
+  Loan,
+  RepayCredit,
+}

package/src/types/buffer-layout/index.d.ts

@@ -0,0 +1,88 @@
+
+declare module 'buffer-layout' {
+  // TODO: remove `any`.
+  export class Layout<T = any> {
+    span: number
+    property?: string
+
+    constructor (span: number, property?: string);
+
+    decode (b: Buffer | string, offset?: number): T;
+    encode (src: T, b: Buffer, offset?: number): number;
+    getSpan (b: Buffer, offset?: number): number;
+    replicate (name: string): this;
+  }
+  // TODO: remove any.
+  export class Structure<T = any> extends Layout<T> {
+    span: any
+  }
+  export function greedy (
+    elementSpan?: number,
+    property?: string,
+  ): Layout<number>
+  export function offset<T> (
+    layout: Layout<T>,
+    offset?: number,
+    property?: string,
+  ): Layout<T>
+  export function u8 (property?: string): Layout<number>
+  export function u16 (property?: string): Layout<number>
+  export function u24 (property?: string): Layout<number>
+  export function u32 (property?: string): Layout<number>
+  export function u40 (property?: string): Layout<number>
+  export function u48 (property?: string): Layout<number>
+  export function nu64 (property?: string): Layout<number>
+  export function u16be (property?: string): Layout<number>
+  export function u24be (property?: string): Layout<number>
+  export function u32be (property?: string): Layout<number>
+  export function u40be (property?: string): Layout<number>
+  export function u48be (property?: string): Layout<number>
+  export function nu64be (property?: string): Layout<number>
+  export function s8 (property?: string): Layout<number>
+  export function s16 (property?: string): Layout<number>
+  export function s24 (property?: string): Layout<number>
+  export function s32 (property?: string): Layout<number>
+  export function s40 (property?: string): Layout<number>
+  export function s48 (property?: string): Layout<number>
+  export function ns64 (property?: string): Layout<number>
+  export function s16be (property?: string): Layout<number>
+  export function s24be (property?: string): Layout<number>
+  export function s32be (property?: string): Layout<number>
+  export function s40be (property?: string): Layout<number>
+  export function s48be (property?: string): Layout<number>
+  export function ns64be (property?: string): Layout<number>
+  export function f32 (property?: string): Layout<number>
+  export function f32be (property?: string): Layout<number>
+  export function f64 (property?: string): Layout<number>
+  export function f64be (property?: string): Layout<number>
+  export function struct<T> (
+    fields: Array<Layout<any>>,
+    property?: string,
+    decodePrefixes?: boolean,
+  ): Layout<T>
+  export function bits (
+    word: Layout<number>,
+    msb?: boolean,
+    property?: string,
+  ): any
+  export function seq<T> (
+    elementLayout: Layout<T>,
+    count: number | Layout<number>,
+    property?: string,
+  ): Layout<T[]>
+  export function union (
+    discr: Layout<any>,
+    defaultLayout?: any,
+    property?: string,
+  ): any
+  export function unionLayoutDiscriminator (
+    layout: Layout<any>,
+    property?: string,
+  ): any
+  export function blob (
+    length: number | Layout<number>,
+    property?: string,
+  ): Layout<Buffer>
+  export function cstr (property?: string): Layout<string>
+  export function utf8 (maxSpan: number, property?: string): Layout<string>
+}

package/src/utils/Errors.ts

@@ -0,0 +1,11 @@
+import { parseIdlErrors, ProgramError } from '@project-serum/anchor'
+import { vaultIdl } from '../idl/idl'
+
+export function parseAnchorErrors (error: any): void {
+  const idlErrors = parseIdlErrors(vaultIdl)
+  const parsedError = ProgramError.parse(error, idlErrors)
+  if (parsedError !== null) {
+    throw parsedError
+  }
+  throw error
+}

package/tsconfig.base.json

@@ -11,8 +11,6 @@
     "emitDecoratorMetadata": true,
     "noImplicitAny": false,
     "strictNullChecks": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
     "composite": true,
     "baseUrl": ".",
     "typeRoots": [
@@ -23,6 +21,8 @@
       "@solana/web3.js": [
         "./node_modules/@solana/web3.js/lib"
       ]
-    }
+    },
+    "resolveJsonModule": true,
+    "esModuleInterop": true 
   }
 }

package/tsconfig.d.json

@@ -2,7 +2,9 @@
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "emitDeclarationOnly": true,
-    "stripInternal": true
+    "stripInternal": true,
+    "resolveJsonModule": true,
+    "esModuleInterop": true,
   },
   "include": [
     "./src/**/*"

package/tsconfig.json

@@ -14,7 +14,7 @@
     "isolatedModules": true,
     "baseUrl": "src",
     "noFallthroughCasesInSwitch": true,
-    "noImplicitReturns": true
+    "noImplicitReturns": true,
   },
   "include": ["src"]
 }

package/src/accounts/LiquidationPoolEra.ts

@@ -1,16 +0,0 @@
-// import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
-// import Decimal from 'decimal.js'
-
-// import { WAD } from './HedgeConstants'
-
-export class LiquidationPoolEra {
-  constructor (public liquidyPoolEra: any) {
-    //     this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber()
-
-    //     this.product = byteArrayToFloat64(liquidyPoolEra.productBytes)
-    //     this.sum = byteArrayToFloat64(liquidyPoolEra.sumBytes)
-    //     this.hedgeRewardsAccumulator = byteArrayToFloat64(liquidyPoolEra.hedgeRewardsAccumulatorBytes)
-
-    //     this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber()
-  }
-}

package/src/accounts/LiquidationPoolState.ts

@@ -1,22 +0,0 @@
-// import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
-// import Decimal from 'decimal.js'
-
-// import { WAD } from './HedgeConstants'
-
-export class LiquidationPoolState {
-  constructor (public liquidationPoolState: any) {
-    //     this.lifetimeDeposits = liquidationPoolState.lifetimeDeposits.toNumber()
-    //     this.hedgeInitRewardsTimestamp = liquidationPoolState.hedgeInitRewardsTimestamp.toNumber()
-    //     // TODO Add the rest that are missing. Do we need them?
-  }
-
-//   getCurrentHedgeRewardsPerDay () {
-//     const dailyRate = hedgeRewardsDecay(
-//       2000000.0 * LAMPORTS_PER_SOL,
-//       this.hedgeInitRewardsTimestamp * 1000,
-//       Date.now(),
-//       Date.now() + (24 * 60 * 60 * 1000),
-//       365 * 1000)
-//     return dailyRate / LAMPORTS_PER_SOL
-//   }
-}

package/src/accounts/LiquidationPosition.ts

@@ -1,72 +0,0 @@
-// import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
-// import Decimal from 'decimal.js'
-// import { LiquidationPoolEra, LiquidationPoolState } from '../Accounts';
-
-import { PublicKey } from '@solana/web3.js'
-import { LiquidationPoolEra } from './LiquidationPoolEra'
-import { LiquidationPoolState } from './LiquidationPoolState'
-
-// import { WAD } from './HedgeConstants'
-
-export class LiquidationPosition {
-//   publicKey: PublicKey;
-//   eraPublicKey: PublicKey;
-//   era: LiquidationPoolEra;
-//   liquidationPoolState: LiquidationPoolEra;
-//   ownerAccount: PublicKey;
-//   deposit: Decimal
-//   closedUsdh: Decimal
-//   closedSol: Decimal
-//   timestampOpened: Date
-//   timestampClosed: Date
-
-  //   productSnapshot: Decimal
-  //   sumSnapshot: Decimal
-  //   hedgeRewardsSnapshot: Decimal
-  //   open: Boolean
-
-  constructor (public poolPositionInfo: any, key: PublicKey, era: LiquidationPoolEra, liquidationPoolState: LiquidationPoolState) {
-    //     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 = new Decimal(poolPositionInfo.productSnapshotBytes.toString())
-    //     this.sumSnapshot = byteArrayToFloat64(poolPositionInfo.sumSnapshotBytes)
-    //     this.hedgeRewardsSnapshot = byteArrayToFloat64(poolPositionInfo.hedgeRewardsSnapshotAccum)
-    //     this.open = !!poolPositionInfo.state.open
-  }
-
-  //   getUsdhAvailable () {
-  //     return (this.deposit * (this.era.product / this.productSnapshot))
-  //   }
-
-  //   getSolAvailable () {
-  //     return Math.floor(this.deposit * ((this.era.sum - this.sumSnapshot) / this.productSnapshot))
-  //   }
-
-  //   getHedgeAvailable () {
-  //     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 0
-  //     }
-
-//     const rewardsPerToken = hedgeRewardsSinceLastUpdate / this.era.totalDeposits * this.era.product
-//     const newAccumulator = this.era.hedgeRewardsAccumulator + rewardsPerToken
-//     const hedgeAvailable = (newAccumulator - this.hedgeRewardsSnapshot) * this.deposit / this.productSnapshot
-//     return hedgeAvailable
-//   }
-}

package/src/accounts/StakingPool.ts

@@ -1,31 +0,0 @@
-// import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js'
-// import Decimal from 'decimal.js'
-
-import { PublicKey } from '@solana/web3.js';
-
-// import { WAD } from './HedgeConstants'
-
-export class StakingPool {
-  constructor (public poolInfo: any, key: PublicKey) {
-    //     this.publicKey = key
-    //     this.deposits = poolInfo.deposits.toNumber()
-    //     // this.totalFeesNow = poolInfo.totalFeesNow.toNumber()
-    //     // this.totalFeesPrevious = poolInfo.totalFeesPrevious.toNumber()
-    //     this.lastTransactionTime = poolInfo.lastTransactionTime.toNumber()
-    //     this.startTime = poolInfo.startTime.toNumber()
-    //     this.halfLifeInDays = poolInfo.halfLifeInDays.toNumber()
-    //     this.totalHedgeReward = poolInfo.totalHedgeReward.toNumber()
-
-    //     this.hedgeRewardAccumulator = byteArrayToFloat64(poolInfo.hedgeRewardAccumulator)
-    //     this.usdhFeeAccumulator = byteArrayToFloat64(poolInfo.usdhFeeAccumulator)
-    //     this.solFeeAccumulator = byteArrayToFloat64(poolInfo.solFeeAccumulator)
-    //     this.currentRewardsPerDay = byteArrayToFloat64(poolInfo.currentRewardsPerDay)
-
-    //     // "stakedTokenMint": { missing
-  }
-
-//   updateFeeAccumulator () {
-//     this.feeAccumulator = (this.totalFeesNow - this.totalFeesPrevious) / this.deposits
-//     this.totalFeesPrevious = this.totalFeesNow
-//   }
-}