hedge-web3 0.1.2 → 0.1.8

package/README.md

@@ -0,0 +1,44 @@
+# Hedge Web3 API
+
+Documentation for the Hedge Web3 TypeScript API.
+
+![NPM Version](https://badge.fury.io/js/hedge-web3.svg)
+
+## Documentation
+
+Documentation can be found here: [https://web3-docs.hedge.so/](https://web3-docs.hedge.so/)
+
+
+## Installation
+
+TypeDoc runs on Node.js and is available as a NPM package.
+
+```sh
+npm install hedge-web3 --save-dev
+```
+
+## Usage
+
+To create a vault, import the package.
+
+```js
+const HedgeWeb3 = require('hedge-web3')
+```
+
+To create a vault and deposit 3 SOL: 
+
+```js
+const vaultPublickey = await HedgeWeb3.createVault(connection, ownerPublicKey, LAMPORTS_PER_SOL * 3, LAMPORTS_PER_SOL * 1.2)
+```
+
+## Contributing
+
+This project is maintained by a community of developers. Contributions are welcome and appreciated.
+You can find Hedge Labs on GitHub; feel free to open an issue or create a pull request:
+https://github.com/Hedge-Finance/hedge-web3
+
+## License
+
+Copyright (c) 2021 [Christopher Coudron](https://hedge.so)<br>
+Copyright (c) 2021 [Hedge Labs Ltd.](https://hedge.so)<br>
+Licensed under the Apache License 2.0.

package/lib/index.js

@@ -11,39 +11,6 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var Decimal__default = /*#__PURE__*/_interopDefaultLegacy(Decimal);
 
-const HEDGE_PROGRAM_ID = 'fff6FuPWrBPzFHeWwtBQaPjKvMvW27w8Jf4P7SSoueX';
-const HEDGE_PROGRAM_PUBLICKEY = new web3_js.PublicKey(HEDGE_PROGRAM_ID);
-const CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf';
-const CHAINLINK_SOL_USD_PUBLICKEY = new web3_js.PublicKey(CHAINLINK_SOL_USD_ID);
-async function getUsdhMintPublicKey() {
-    const enc = new TextEncoder();
-    const [findMintPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [findMintPublicKey, bump];
-}
-async function getVaultSystemStatePublicKey() {
-    const enc = new TextEncoder();
-    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [publicKey, bump];
-}
-async function getHedgeMintPublicKey() {
-    const enc = new TextEncoder();
-    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [publicKey, bump];
-}
-async function getPoolPublicKeyForMint(mintPublicKey) {
-    const enc = new TextEncoder();
-    const strToEncode = (mintPublicKey.toString().substring(0, 12));
-    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode(strToEncode)], HEDGE_PROGRAM_PUBLICKEY);
-    return [publicKey, bump, strToEncode];
-}
-async function findAssociatedTokenAddress(walletAddress, tokenMintAddress) {
-    return (await web3_js.PublicKey.findProgramAddress([
-        walletAddress.toBuffer(),
-        splToken.TOKEN_PROGRAM_ID.toBuffer(),
-        tokenMintAddress.toBuffer()
-    ], splToken.ASSOCIATED_TOKEN_PROGRAM_ID))[0];
-}
-
 const vaultIdl = {
     version: '0.1.0',
     name: 'vault',
@@ -1517,20 +1484,169 @@ const vaultIdl = {
     ]
 };
 
-async function createVault(connection, payer, depositAmount, collateralRatio, confirmOptions) {
+function parseAnchorErrors(error) {
+    const idlErrors = anchor.parseIdlErrors(vaultIdl);
+    const parsedError = anchor.ProgramError.parse(error, idlErrors);
+    if (parsedError !== null) {
+        throw parsedError;
+    }
+    throw error;
+}
+
+const HEDGE_PROGRAM_ID = 'hhhJmQPMmb2sNoTQK1ip7ZRGpRdGfskEEgjacf9XFWv';
+const HEDGE_PROGRAM_PUBLICKEY = new web3_js.PublicKey(HEDGE_PROGRAM_ID);
+const CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf';
+const CHAINLINK_SOL_USD_PUBLICKEY = new web3_js.PublicKey(CHAINLINK_SOL_USD_ID);
+async function getLiquidationPoolStatePublicKey() {
+    const enc = new TextEncoder();
+    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [poolPublicKey, bump];
+}
+async function getLiquidationPoolUsdhAccountPublicKey() {
+    const enc = new TextEncoder();
+    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [poolPublicKey, bump];
+}
+async function getUsdhMintPublicKey() {
+    const enc = new TextEncoder();
+    const [findMintPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [findMintPublicKey, bump];
+}
+async function getVaultSystemStatePublicKey() {
+    const enc = new TextEncoder();
+    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [publicKey, bump];
+}
+async function getHedgeMintPublicKey() {
+    const enc = new TextEncoder();
+    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [publicKey, bump];
+}
+async function getPoolPublicKeyForMint(mintPublicKey) {
+    const enc = new TextEncoder();
+    const strToEncode = (mintPublicKey.toString().substring(0, 12));
+    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode(strToEncode)], HEDGE_PROGRAM_PUBLICKEY);
+    return [publicKey, bump, strToEncode];
+}
+async function findAssociatedTokenAddress(walletAddress, tokenMintAddress) {
+    return (await web3_js.PublicKey.findProgramAddress([
+        walletAddress.toBuffer(),
+        splToken.TOKEN_PROGRAM_ID.toBuffer(),
+        tokenMintAddress.toBuffer()
+    ], splToken.ASSOCIATED_TOKEN_PROGRAM_ID))[0];
+}
+
+async function createStakingPool(program, provider, payer, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
+    const transaction = new web3_js.Transaction().add(await createStakingPoolInstruction(program, payer.publicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
+    const [poolPublickey] = await getPoolPublicKeyForMint(mintPublicKey);
+    return poolPublickey;
+}
+async function createStakingPoolInstruction(program, payerPublicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
+    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const [poolPublickey, poolBump, poolSeedPhrase] = await getPoolPublicKeyForMint(mintPublicKey);
+    const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey);
+    const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey);
+    return program.instruction.createStakingPool(poolBump, poolSeedPhrase, new anchor.BN(hedgeTokensToBeMinted), new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), {
+        accounts: {
+            signer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublickey,
+            stakedTokenMintInfo: mintPublicKey,
+            usdhMint: usdhMintPublickey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function depositStakingPool(program, provider, payer, mintPublicKey, depositAmount, overrideStartTime) {
+    const poolPosition = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await depositStakingPoolInstruction(program, payer.publicKey, poolPosition.publicKey, mintPublicKey, depositAmount, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors);
+    return poolPosition.publicKey;
+}
+async function depositStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
+    const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey);
+    const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey);
+    const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey);
+    return program.instruction.depositStakingPool(new anchor.BN(depositAmount), new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            payer: payerPublicKey,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            stakedTokenMintInfo: stakedTokenMintPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function withdrawStakingPool(program, provider, payer, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
+    const poolPosition = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await withdrawStakingPoolInstruction(program, payer.publicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
+    return poolPosition.publicKey;
+}
+async function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
+    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);
+    return program.instruction.withdrawStakingPool(new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+            payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
+            payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+            payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
+            hedgeMint: hedgeMintPublickey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            usdhMint: usdhMintPublickey,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function createVault(program, provider, payer, depositAmount, collateralRatio) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const newVault = web3_js.Keypair.generate();
     const history = web3_js.Keypair.generate();
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(createVaultInstruction(vaultSystemStatePublicKey, payer.publicKey, newVault.publicKey, history.publicKey, depositAmount, collateralRatio));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, newVault, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(createVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, newVault.publicKey, history.publicKey, depositAmount, collateralRatio));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, newVault, history], provider === null || provider === void 0 ? void 0 : provider.opts);
     return newVault.publicKey;
 }
-function createVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount, collateralRatio) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+function createVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount, collateralRatio) {
     const ix = program.instruction.createVault(new anchor.BN(depositAmount), new anchor.BN(collateralRatio), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
@@ -1544,19 +1660,18 @@ function createVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vault
     return ix;
 }
 
-async function depositVault(connection, payer, vaultPublicKey, depositAmount, confirmOptions) {
+async function depositVault(program, provider, payer, vaultPublicKey, depositAmount) {
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(depositVaultInstruction(vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, depositAmount));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, depositAmount));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-function depositVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+function depositVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount) {
     return program.instruction.depositVault(new anchor.BN(depositAmount), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
@@ -1569,19 +1684,18 @@ function depositVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaul
     });
 }
 
-async function withdrawVault(connection, payer, vaultPublicKey, withdrawAmount, chainlinkOverridePrice, confirmOptions) {
+async function withdrawVault(program, provider, payer, vaultPublicKey, withdrawAmount, chainlinkOverridePrice) {
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(withdrawVaultInstruction(vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, withdrawAmount, chainlinkOverridePrice));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, withdrawAmount, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-function withdrawVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublickey, historyPublicKey, withdrawAmount, chainlinkOverridePrice) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublickey, historyPublicKey, withdrawAmount, chainlinkOverridePrice) {
     return program.instruction.withdrawVault(new anchor.BN(withdrawAmount), new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : 200 * web3_js.LAMPORTS_PER_SOL), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
@@ -1595,18 +1709,17 @@ function withdrawVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vau
     });
 }
 
-async function loanVault(connection, payer, vaultPublicKey, loanAmount, chainlinkOverridePrice, confirmOptions) {
+async function loanVault(program, provider, payer, vaultPublicKey, loanAmount, chainlinkOverridePrice) {
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await loanVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, loanAmount, chainlinkOverridePrice));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(await loanVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, loanAmount, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function loanVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, loanAmount, chainlinkOverridePrice) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+async function loanVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, loanAmount, chainlinkOverridePrice) {
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
     const [hedgeMintPublickey] = await getHedgeMintPublicKey();
@@ -1631,18 +1744,17 @@ async function loanVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPubli
     });
 }
 
-async function repayVault(connection, payer, vaultPublicKey, repayAmount, confirmOptions) {
+async function repayVault(program, provider, payer, vaultPublicKey, repayAmount) {
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await repayVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(await repayVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function repayVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+async function repayVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount) {
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
     const [hedgeMintPublickey] = await getHedgeMintPublicKey();
@@ -1665,18 +1777,17 @@ async function repayVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPubl
     });
 }
 
-async function redeemVault(connection, payer, vaultPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime, confirmOptions) {
+async function redeemVault(program, provider, payer, vaultPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime) {
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await redeemVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime));
-    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    const transaction = new web3_js.Transaction().add(await redeemVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function redeemVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime) {
-    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+async function redeemVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime) {
     const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
     const [usdhMintPublickey] = await getUsdhMintPublicKey();
     const [hedgeMintPublickey] = await getHedgeMintPublicKey();
@@ -1702,6 +1813,42 @@ async function redeemVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPub
     });
 }
 
+async function liquidateVault(program, provider, payer, vaultPublicKey, chainlinkOverridePrice) {
+    const history = web3_js.Keypair.generate();
+    const newEra = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await liquidateVaultInstruction(program, payer.publicKey, vaultPublicKey, history.publicKey, newEra.publicKey, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts);
+    return vaultPublicKey;
+}
+async function liquidateVaultInstruction(program, payerPublicKey, vaultPublickey, historyPublicKey, newEraPublicKey, chainlinkOverridePrice) {
+    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
+    const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
+    const [liquidationPoolStatePublicKey] = await getLiquidationPoolStatePublicKey();
+    const [liquidationPoolUsdhAccountPublickey] = await getLiquidationPoolUsdhAccountPublicKey();
+    const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+    return program.instruction.liquidateVault(new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : web3_js.LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            poolEra: poolStateInfo.currentEra,
+            vaultAccount: vaultPublickey,
+            poolState: liquidationPoolStatePublicKey,
+            usdhMint: usdhMintPublickey,
+            chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+            history: historyPublicKey,
+            payer: payerPublicKey,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            feePool: hedgeStakingPoolPublicKey,
+            liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+            newEra: newEraPublicKey
+        },
+        signers: []
+    });
+}
+
 /**
    * Convert a U128 to a Decimal
    *
@@ -1730,7 +1877,6 @@ class VaultAccount {
         this.deposited = vault.deposited.toNumber();
         this.minCollateralRatio = DecimalFromU128(vault.minCollateralRatio);
         this.liquidationPrice = vault.liquidationPrice.toNumber();
-        this.minCollateralRatio = vault.minCollateralRatio.toNumber();
         this.vaultStatus = Object.keys(vault.vaultStatus)[0];
     }
     /**
@@ -1768,23 +1914,189 @@ class VaultAccount {
     }
 }
 
-function foo(input) {
-    console.log('Input', input);
+class VaultHistoryEvent {
+    constructor(account, publicKey) {
+        this.account = account;
+        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;
+    }
+}
+exports.VaultStatus = void 0;
+(function (VaultStatus) {
+    VaultStatus[VaultStatus["Open"] = 0] = "Open";
+    VaultStatus[VaultStatus["Closed"] = 1] = "Closed";
+    VaultStatus[VaultStatus["Liquidated"] = 2] = "Liquidated";
+    VaultStatus[VaultStatus["Distributed"] = 3] = "Distributed";
+    VaultStatus[VaultStatus["Redeemed"] = 4] = "Redeemed";
+})(exports.VaultStatus || (exports.VaultStatus = {}));
+exports.VaultHistoryAction = void 0;
+(function (VaultHistoryAction) {
+    VaultHistoryAction[VaultHistoryAction["Create"] = 0] = "Create";
+    VaultHistoryAction[VaultHistoryAction["Close"] = 1] = "Close";
+    VaultHistoryAction[VaultHistoryAction["Liquidate"] = 2] = "Liquidate";
+    VaultHistoryAction[VaultHistoryAction["PartialLiquidate"] = 3] = "PartialLiquidate";
+    VaultHistoryAction[VaultHistoryAction["Distributed"] = 4] = "Distributed";
+    VaultHistoryAction[VaultHistoryAction["Redeem"] = 5] = "Redeem";
+    VaultHistoryAction[VaultHistoryAction["TransferOwnership"] = 6] = "TransferOwnership";
+    VaultHistoryAction[VaultHistoryAction["Deposit"] = 7] = "Deposit";
+    VaultHistoryAction[VaultHistoryAction["Withdraw"] = 8] = "Withdraw";
+    VaultHistoryAction[VaultHistoryAction["Loan"] = 9] = "Loan";
+    VaultHistoryAction[VaultHistoryAction["RepayCredit"] = 10] = "RepayCredit";
+})(exports.VaultHistoryAction || (exports.VaultHistoryAction = {}));
+
+class StakingPool {
+    constructor(poolInfo, publicKey) {
+        this.poolInfo = poolInfo;
+        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)
+    }
+}
+
+class StakingPoolPosition {
+    constructor(poolPositionInfo, key, stakingPool) {
+        this.poolPositionInfo = poolPositionInfo;
+        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() {
+        return this.pool.usdhFeeAccumulator.minus(this.startUsdhFeeAccumulator).times(new Decimal__default["default"](this.deposited));
+    }
+}
+
+/**
+ * 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.
+ */
+class LiquidationPoolEra {
+    constructor(liquidyPoolEra) {
+        this.liquidyPoolEra = liquidyPoolEra;
+        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();
+    }
+}
+
+class LiquidationPoolState {
+    constructor(liquidationPoolState) {
+        this.liquidationPoolState = liquidationPoolState;
+        this.lifetimeDeposits = liquidationPoolState.lifetimeDeposits.toNumber();
+        this.hedgeInitRewardsTimestamp = liquidationPoolState.hedgeInitRewardsTimestamp.toNumber();
+        // TODO Add the rest that are missing. Do we need them?
+    }
+}
+
+class LiquidationPosition {
+    constructor(poolPositionInfo, key, era, 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;
+    }
+    getUsdhAvailable() {
+        return (this.era.product.div(this.productSnapshot)).mul(new Decimal__default["default"](this.deposit));
+    }
+    getSolAvailable() {
+        return this.era.sum.minus(this.sumSnapshot).div(this.productSnapshot).mul(new Decimal__default["default"](this.deposit)).floor();
+    }
+    getHedgeAvailable() {
+        const LiquidationPoolTotalSupply = 2000000.0 * web3_js.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__default["default"](0);
+        }
+        const rewardsPerToken = this.era.product.mul(new Decimal__default["default"](hedgeRewardsSinceLastUpdate / this.era.totalDeposits));
+        const newAccumulator = rewardsPerToken.add(new Decimal__default["default"](this.era.hedgeRewardsAccumulator));
+        const hedgeAvailable = (newAccumulator.minus(this.hedgeRewardsSnapshot)).mul(new Decimal__default["default"](this.deposit)).div(new Decimal__default["default"](this.productSnapshot));
+        return hedgeAvailable;
+    }
+}
+function hedgeRewardsDecay(supply, birthTime, timeIn, timeOut, halfLifeInDays) {
+    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;
 }
 
+exports.CHAINLINK_SOL_USD_ID = CHAINLINK_SOL_USD_ID;
+exports.CHAINLINK_SOL_USD_PUBLICKEY = CHAINLINK_SOL_USD_PUBLICKEY;
 exports.DecimalFromU128 = DecimalFromU128;
+exports.HEDGE_PROGRAM_ID = HEDGE_PROGRAM_ID;
+exports.HEDGE_PROGRAM_PUBLICKEY = HEDGE_PROGRAM_PUBLICKEY;
+exports.LiquidationPoolEra = LiquidationPoolEra;
+exports.LiquidationPoolState = LiquidationPoolState;
+exports.LiquidationPosition = LiquidationPosition;
+exports.StakingPool = StakingPool;
+exports.StakingPoolPosition = StakingPoolPosition;
 exports.VaultAccount = VaultAccount;
+exports.VaultHistoryEvent = VaultHistoryEvent;
+exports.createStakingPool = createStakingPool;
+exports.createStakingPoolInstruction = createStakingPoolInstruction;
 exports.createVault = createVault;
 exports.createVaultInstruction = createVaultInstruction;
+exports.depositStakingPool = depositStakingPool;
+exports.depositStakingPoolInstruction = depositStakingPoolInstruction;
 exports.depositVault = depositVault;
 exports.depositVaultInstruction = depositVaultInstruction;
-exports.foo = foo;
+exports.findAssociatedTokenAddress = findAssociatedTokenAddress;
+exports.getHedgeMintPublicKey = getHedgeMintPublicKey;
+exports.getLiquidationPoolStatePublicKey = getLiquidationPoolStatePublicKey;
+exports.getLiquidationPoolUsdhAccountPublicKey = getLiquidationPoolUsdhAccountPublicKey;
+exports.getPoolPublicKeyForMint = getPoolPublicKeyForMint;
+exports.getUsdhMintPublicKey = getUsdhMintPublicKey;
+exports.getVaultSystemStatePublicKey = getVaultSystemStatePublicKey;
+exports.liquidateVault = liquidateVault;
+exports.liquidateVaultInstruction = liquidateVaultInstruction;
 exports.loanVault = loanVault;
 exports.loanVaultInstruction = loanVaultInstruction;
 exports.redeemVault = redeemVault;
 exports.redeemVaultInstruction = redeemVaultInstruction;
 exports.repayVault = repayVault;
 exports.repayVaultInstruction = repayVaultInstruction;
+exports.withdrawStakingPool = withdrawStakingPool;
+exports.withdrawStakingPoolInstruction = withdrawStakingPoolInstruction;
 exports.withdrawVault = withdrawVault;
 exports.withdrawVaultInstruction = withdrawVaultInstruction;
 //# sourceMappingURL=index.js.map