hedge-web3 0.1.1 → 0.1.2

package/src/index.ts

@@ -3,5 +3,11 @@ export function foo (input: String): void {
   console.log('Input', input)
 }
 
-export * from './accounts/VaultAccount'
+export * from './instructions/createVault'
+export * from './instructions/depositVault'
+export * from './instructions/withdrawVault'
+export * from './instructions/loanVault'
+export * from './instructions/repayVault'
+export * from './instructions/redeemVault'
+export * from './state/VaultAccount'
 export * from './HedgeDecimal'

package/src/instructions/createVault.ts

@@ -0,0 +1,66 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function createVault (
+  connection: Connection,
+  payer: Signer,
+  depositAmount: number,
+  collateralRatio: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const newVault = Keypair.generate()
+  const history = Keypair.generate()
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const transaction = new Transaction().add(
+    createVaultInstruction(
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      newVault.publicKey,
+      history.publicKey,
+      depositAmount,
+      collateralRatio
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, newVault, history], confirmOptions)
+  return newVault.publicKey
+}
+
+export function createVaultInstruction (
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  historyPublicKey: PublicKey,
+  depositAmount: number,
+  collateralRatio: number
+): TransactionInstruction {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const ix = program.instruction.createVault(
+    new BN(depositAmount),
+    new BN(collateralRatio)
+    , {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vault: vaultPublicKey,
+        history: historyPublicKey,
+        payer: payerPublicKey,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+  return ix
+}

package/src/instructions/depositVault.ts

@@ -0,0 +1,61 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function depositVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  depositAmount: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    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(
+    depositVaultInstruction(
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      vaultPublicKey,
+      history.publicKey,
+      depositAmount
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export function depositVaultInstruction (
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublicKey: PublicKey,
+  historyPublicKey: PublicKey,
+  depositAmount: number
+): TransactionInstruction {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  return program.instruction.depositVault(
+    new BN(depositAmount)
+    , {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublicKey,
+        history: historyPublicKey,
+        vaultOwner: payerPublicKey,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/loanVault.ts

@@ -0,0 +1,79 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function loanVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  loanAmount: number,
+  chainlinkOverridePrice?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await loanVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      loanAmount,
+      chainlinkOverridePrice
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function loanVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  loanAmount: number,
+  chainlinkOverridePrice?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.loanVault(
+    new BN(loanAmount),
+    new BN(chainlinkOverridePrice ?? LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        vaultOwner: payerPublicKey,
+        ownerUsdhAccount: ownerUsdhAccount,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/redeemVault.ts

@@ -0,0 +1,83 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function redeemVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  repayAmount: number,
+  chainlinkOverridePrice?: number,
+  transactionOverrideTime?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await redeemVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      repayAmount,
+      chainlinkOverridePrice,
+      transactionOverrideTime
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function redeemVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  repayAmount: number,
+  chainlinkOverridePrice?: number,
+  transactionOverrideTime?: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.redeemVault(
+    new BN(repayAmount),
+    new BN(chainlinkOverridePrice ?? 150 * LAMPORTS_PER_SOL), // override usd/sol price
+    new BN(transactionOverrideTime ?? (Date.now() / 1000)), // override start time
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        payer: payerPublicKey,
+        payerUsdhAccount: ownerUsdhAccount,
+        chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/repayVault.ts

@@ -0,0 +1,74 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { findAssociatedTokenAddress, getHedgeMintPublicKey, getPoolPublicKeyForMint, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function repayVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  repayAmount: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    connection,
+    usdhMintPublickey,
+    TOKEN_PROGRAM_ID,
+    payer
+  )
+
+  // Prep the user to get USDH back out at some point
+  const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey)
+
+  const history = Keypair.generate()
+  const transaction = new Transaction().add(
+    await repayVaultInstruction(
+      payer.publicKey,
+      payerUsdhAccount.address,
+      vaultPublicKey,
+      history.publicKey,
+      repayAmount
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export async function repayVaultInstruction (
+  payerPublicKey: PublicKey,
+  ownerUsdhAccount: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  repayAmount: number
+): Promise<TransactionInstruction> {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey()
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const [hedgeMintPublickey] = await getHedgeMintPublicKey()
+  const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey)
+  const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(
+    hedgeStakingPoolPublicKey,
+    usdhMintPublickey
+  )
+
+  return program.instruction.repayVault(
+    new BN(repayAmount),
+    {
+      accounts: {
+        vaultSystemState: vaultSystemStatePublicKey,
+        vaultAccount: vaultPublickey,
+        history: historyPublicKey,
+        feePool: hedgeStakingPoolPublicKey,
+        feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+        usdhMint: usdhMintPublickey,
+        vaultOwner: payerPublicKey,
+        ownerUsdhAccount: ownerUsdhAccount,
+        splTokenProgramInfo: TOKEN_PROGRAM_ID,
+        systemProgram: SystemProgram.programId
+      },
+      signers: []
+    })
+}

package/src/instructions/withdrawVault.ts

@@ -0,0 +1,66 @@
+import { BN, Program } from '@project-serum/anchor'
+import { Token, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import { ConfirmOptions, Connection, Keypair, LAMPORTS_PER_SOL, PublicKey, sendAndConfirmTransaction, Signer, SystemProgram, Transaction, TransactionInstruction } from '@solana/web3.js'
+import { CHAINLINK_SOL_USD_PUBLICKEY, getUsdhMintPublicKey, getVaultSystemStatePublicKey, HEDGE_PROGRAM_ID } from '../Constants'
+
+import { vaultIdl } from '../idl/idl'
+
+export async function withdrawVault (
+  connection: Connection,
+  payer: Signer,
+  vaultPublicKey: PublicKey,
+  withdrawAmount: number,
+  chainlinkOverridePrice?: number,
+  confirmOptions?: ConfirmOptions
+): Promise<PublicKey> {
+  const [usdhMintPublickey] = await getUsdhMintPublicKey()
+  const USDH = new Token(
+    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(
+      vaultSystemStatePublicKey,
+      payer.publicKey,
+      vaultPublicKey,
+      history.publicKey,
+      withdrawAmount,
+      chainlinkOverridePrice
+    )
+  )
+  await sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions)
+  return vaultPublicKey
+}
+
+export function withdrawVaultInstruction (
+  vaultSystemStatePublicKey: PublicKey,
+  payerPublicKey: PublicKey,
+  vaultPublickey: PublicKey,
+  historyPublicKey: PublicKey,
+  withdrawAmount: number,
+  chainlinkOverridePrice?: number
+): TransactionInstruction {
+  const program = new Program(vaultIdl, HEDGE_PROGRAM_ID)
+  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 '..'
+
+/**
+ * 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
+
+  product: Decimal
+
+  sum: Decimal
+
+  hedgeRewardsAccumulator: Decimal
+
+  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,69 @@
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '..'
+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()
+  }
+
+  //   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/state/StakingPool.ts

@@ -0,0 +1,39 @@
+
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '..'
+
+export class StakingPool {
+  public publicKey: PublicKey
+  public deposits: number
+  lastTransactionTime: number
+  startTime: number
+  halfLifeInDays: number
+  totalHedgeReward: number
+
+  hedgeRewardAccumulator: Decimal
+  usdhFeeAccumulator: Decimal
+  solFeeAccumulator: Decimal
+  currentRewardsPerDay: Decimal
+
+  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 = 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,40 @@
+
+import { PublicKey } from '@solana/web3.js'
+import Decimal from 'decimal.js'
+import { DecimalFromU128 } from '..'
+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
+  }
+
+//   getCurrentUsdhFeeReward () {
+//     const feesAccured = (this.pool.usdhFeeAccumulator - this.startUsdhFeeAccumulator) * this.deposited
+//     return feesAccured
+//   }
+}

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,13 +27,12 @@ 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]