hedge-web3 0.1.13 → 0.1.16

package/lib/instructions/liquidateVault.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.liquidateVaultInstruction = exports.liquidateVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const collateralMint = vaultTypeAccountInfo.collateralMint;
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(hedgeMintPublickey);
+        const liquidationPoolStatePublicKey = yield (0, Constants_1.getLiquidationPoolStatePublicKey)();
+        const poolStateInfo = yield program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, payer.publicKey, true);
+        const feePoolAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, hedgeStakingPoolPublicKey, true);
+        const vaultAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, vaultPublicKey, true);
+        const poolAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, liquidationPoolStatePublicKey, true);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, vaultTypeAccountPublicKey, true);
+        const hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, hedgeStakingPoolPublicKey, true);
+        const history = web3_js_1.Keypair.generate();
+        const newEra = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction();
+        transaction.add(yield liquidateVaultInstruction(program, payer.publicKey, payerAssociatedTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, liquidationPoolStatePublicKey, poolStateInfo.currentEra, poolAssociatedTokenAccount.address, history.publicKey, newEra.publicKey, hedgeStakingPoolPublicKey, feePoolAssociatedTokenAccount.address, hedgeStakingPoolAssociatedUsdhTokenAccount.address, collateralMint, vaultTypeAssociatedTokenAccount.address, vaultAccount.collateralType, overrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history, newEra], provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.liquidateVault = liquidateVault;
+function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, poolState, poolEra, poolAssociatedTokenAccount, historyPublicKey, newEraPublicKey, feePool, feePoolAssociatedTokenAccount, hedgeStakingPoolAssociatedUsdhTokenAccount, collateralMint, vaultTypeAssociatedTokenAccount, collateralType, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const liquidationPoolUsdhAccountPublickey = yield (0, Constants_1.getLiquidationPoolUsdhAccountPublicKey)();
+        const vaultTypeAccount = yield (0, Constants_1.getVaultTypeAccountPublicKey)(collateralType);
+        const payload = {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                collateralMint: collateralMint,
+                poolEra: poolEra,
+                vaultAccount: vaultPublickey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                poolState: poolState,
+                poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+                usdhMint: usdhMintPublickey,
+                history: historyPublicKey,
+                payer: payerPublicKey,
+                payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+                feePool: feePool,
+                feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+                newEra: newEraPublicKey,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+            },
+            signers: []
+        };
+        return program.instruction.liquidateVault(new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        payload);
+    });
+}
+exports.liquidateVaultInstruction = liquidateVaultInstruction;

package/lib/instructions/loanVault.js

@@ -0,0 +1,61 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loanVaultInstruction = exports.loanVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const payerUsdhAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, payer.publicKey);
+        const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccount.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccount.collateralMint, vaultPublicKey, true);
+        const history = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield loanVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, loanAmount, overrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.loanVault = loanVault;
+function loanVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, loanAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(hedgeMintPublickey);
+        const hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        return program.instruction.loanVault(new anchor_1.BN(loanAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                vaultAccount: vaultPublickey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                history: historyPublicKey,
+                feePool: hedgeStakingPoolPublicKey,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                usdhMint: usdhMintPublickey,
+                vaultOwner: payerPublicKey,
+                ownerUsdhAccount: ownerUsdhAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.loanVaultInstruction = loanVaultInstruction;

package/lib/instructions/redeemVault.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeemVaultInstruction = exports.redeemVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+// import { TokenInstructions } from '@project-serum/serum'
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function redeemVault(program, provider, payer, vaultPublicKey, redeemAmount, transactionOverrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        // Prep the user to get USDH back out at some point
+        const payerUsdhAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, payer.publicKey);
+        const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultPublicKey, true);
+        const payerTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey);
+        const history = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield redeemVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, payerTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, redeemAmount, transactionOverrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.redeemVault = redeemVault;
+function redeemVaultInstruction(program, payerPublicKey, payerUsdhAccount, destinationTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, redeemAmount, transactionOverrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(hedgeMintPublickey);
+        const hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        return program.instruction.redeemVault(new anchor_1.BN(redeemAmount), new anchor_1.BN(transactionOverrideTime !== null && transactionOverrideTime !== void 0 ? transactionOverrideTime : (Date.now() / 1000)), // override start time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                vault: vaultPublickey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                history: historyPublicKey,
+                feePool: hedgeStakingPoolPublicKey,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                usdhMint: usdhMintPublickey,
+                payer: payerPublicKey,
+                payerUsdhAccount: payerUsdhAccount,
+                destinationTokenAccount: destinationTokenAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.redeemVaultInstruction = redeemVaultInstruction;

package/lib/instructions/refreshOraclePrice.js

@@ -0,0 +1,65 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshOraclePriceInstruction = exports.refreshOraclePrice = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function refreshOraclePrice(program, provider, payer, collateralType, network, overridePrice, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const transaction = new web3_js_1.Transaction().add(yield refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime));
+        return yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts);
+    });
+}
+exports.refreshOraclePrice = refreshOraclePrice;
+function refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const enc = new TextEncoder();
+        const [oracleInfoAccount] = yield web3_js_1.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], Constants_1.HEDGE_PROGRAM_PUBLICKEY);
+        const [vaultTypeAccount] = yield web3_js_1.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], Constants_1.HEDGE_PROGRAM_PUBLICKEY);
+        return program.instruction.refreshOraclePrice(new anchor_1.BN(overridePrice !== null && overridePrice !== void 0 ? overridePrice : web3_js_1.LAMPORTS_PER_SOL * 150), // override usd/sol price
+        new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                oracleInfoAccount: oracleInfoAccount,
+                vaultTypeAccount: vaultTypeAccount,
+                oracleChainlink: chainlinkAccunts[network],
+                oraclePyth: pythAccounts[network],
+                oracleSwitchboard: switchboardAccounts[network],
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.refreshOraclePriceInstruction = refreshOraclePriceInstruction;
+var Cluster;
+(function (Cluster) {
+    Cluster["Testing"] = "Testing";
+    Cluster["Devnet"] = "Devnet";
+    Cluster["MainnetBeta"] = "MainnetBeta";
+})(Cluster || (Cluster = {}));
+const pythAccounts = {
+    Testing: web3_js_1.SystemProgram.programId,
+    Devnet: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+    MainnetBeta: new web3_js_1.PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG')
+};
+const chainlinkAccunts = {
+    Testing: web3_js_1.SystemProgram.programId,
+    Devnet: new web3_js_1.PublicKey('FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'),
+    MainnetBeta: web3_js_1.SystemProgram.programId // CHAINLINK NOT ON MAINNET YET
+};
+const switchboardAccounts = {
+    Testing: web3_js_1.SystemProgram.programId,
+    // Devnet: new PublicKey('GvDMxPzN1sCj7L26YDK2HnMRXEQmQ2aemov8YBtPS7vR'),
+    Devnet: new web3_js_1.PublicKey('DpoK8Zz69APV9ntjuY9C4LZCxANYMV56M2cbXEdkjxME'),
+    MainnetBeta: web3_js_1.SystemProgram.programId // Switchboard V2 NOT ON MAINNET YET
+};

package/lib/instructions/repayVault.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repayVaultInstruction = exports.repayVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function repayVault(program, provider, payer, vaultPublicKey, repayAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        // Prep the user to get USDH back out at some point
+        const payerUsdhAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, payer.publicKey);
+        const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const vaultTypeAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultTypeAccountPublicKey, vaultTypeAccount.collateralMint);
+        const vaultAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultPublicKey, vaultTypeAccount.collateralMint);
+        const history = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield repayVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, repayAmount, overrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.repayVault = repayVault;
+function repayVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, repayAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(hedgeMintPublickey);
+        const hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        return program.instruction.repayVault(new anchor_1.BN(repayAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                vaultAccount: vaultPublickey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                history: historyPublicKey,
+                feePool: hedgeStakingPoolPublicKey,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                usdhMint: usdhMintPublickey,
+                vaultOwner: payerPublicKey,
+                ownerUsdhAccount: ownerUsdhAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.repayVaultInstruction = repayVaultInstruction;

package/lib/instructions/setHalted.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHaltedInstruction = exports.setHalted = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+function setHalted(program, provider, payer, halted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const transaction = new web3_js_1.Transaction().add(yield setHaltedInstruction(program, vaultSystemStatePublicKey, payer.publicKey, halted));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider === null || provider === void 0 ? void 0 : provider.opts).catch(Errors_1.parseAnchorErrors);
+        return vaultSystemStatePublicKey;
+    });
+}
+exports.setHalted = setHalted;
+function setHaltedInstruction(program, vaultSystemStatePublicKey, payerPublicKey, halted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ix = program.instruction.setHalted(halted, {
+            accounts: {
+                payer: payerPublicKey,
+                vaultSystemState: vaultSystemStatePublicKey,
+            },
+            signers: []
+        });
+        return ix;
+    });
+}
+exports.setHaltedInstruction = setHaltedInstruction;

package/lib/instructions/withdrawStakingPool.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawStakingPoolInstruction = exports.withdrawStakingPool = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Errors_1 = require("../utils/Errors");
+const Constants_1 = require("../Constants");
+function withdrawStakingPool(program, provider, payer, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const poolPosition = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield withdrawStakingPoolInstruction(program, payer.publicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return poolPosition.publicKey;
+    });
+}
+exports.withdrawStakingPool = withdrawStakingPool;
+function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(stakedTokenMintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, stakedTokenMintPublicKey);
+        const poolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, usdhMintPublickey);
+        const payerAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, stakedTokenMintPublicKey);
+        const payerAssociatedHedgeAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, hedgeMintPublickey);
+        const payerAssociatedUsdhAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, usdhMintPublickey);
+        const communityHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultSystemStatePublicKey, hedgeMintPublickey);
+        return program.instruction.withdrawStakingPool(new anchor_1.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,
+                communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+                hedgeMint: hedgeMintPublickey,
+                stakedTokenMint: stakedTokenMintPublicKey,
+                usdhMint: usdhMintPublickey,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.withdrawStakingPoolInstruction = withdrawStakingPoolInstruction;

package/lib/instructions/withdrawVault.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawVaultInstruction = exports.withdrawVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const spl_token_1 = require("@solana/spl-token");
+const serum_1 = require("@project-serum/serum");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function withdrawVault(program, provider, payer, vaultPublicKey, withdrawAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        // Prep the user to get USDH back out at some point
+        yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, payer.publicKey);
+        const history = web3_js_1.Keypair.generate();
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
+        const vaultTypeAccount = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const vaultAssociatedCollateralAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, serum_1.TokenInstructions.WRAPPED_SOL_MINT, vaultPublicKey, true);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccount);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccount, true);
+        const destinationTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, payer.publicKey);
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(yield (0, Constants_1.getHedgeMintPublicKey)());
+        const hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        const transaction = new web3_js_1.Transaction().add(yield withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, destinationTokenAccount.address, vaultPublicKey, vaultAssociatedCollateralAccount.address, vaultTypeAccount, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUsdhTokenAccount, usdhMintPublickey, history.publicKey, withdrawAmount, overrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.withdrawVault = withdrawVault;
+function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, destinationTokenAccount, vaultPublickey, vaultAssociatedCollateralPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUsdhTokenAccount, usdhMint, historyPublicKey, withdrawAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return program.instruction.withdrawVault(new anchor_1.BN(withdrawAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                vault: vaultPublickey,
+                vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
+                feePool: hedgeStakingPoolPublicKey,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                usdhMint: usdhMint,
+                history: historyPublicKey,
+                vaultOwner: payerPublicKey,
+                destinationTokenAccount: destinationTokenAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId
+            },
+            signers: []
+        });
+    });
+}
+exports.withdrawVaultInstruction = withdrawVaultInstruction;

package/lib/state/LiquidationPoolEra.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidationPoolEra = void 0;
+const HedgeDecimal_1 = require("../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.
+ */
+class LiquidationPoolEra {
+    constructor(liquidyPoolEra) {
+        this.liquidyPoolEra = liquidyPoolEra;
+        this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber();
+        this.product = (0, HedgeDecimal_1.DecimalFromU128)(liquidyPoolEra.productBytes);
+        this.sum = liquidyPoolEra.sumBytes.map((sumBytes) => { return (0, HedgeDecimal_1.DecimalFromU128)(sumBytes); });
+        this.hedgeRewardsAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(liquidyPoolEra.hedgeRewardsAccumulatorBytes);
+        this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber();
+    }
+}
+exports.LiquidationPoolEra = LiquidationPoolEra;

package/lib/state/LiquidationPoolState.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidationPoolState = void 0;
+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?
+    }
+}
+exports.LiquidationPoolState = LiquidationPoolState;

package/lib/state/LiquidationPosition.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidationPosition = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+class LiquidationPosition {
+    constructor(poolPositionInfo, key) {
+        this.publicKey = key;
+        this.eraPublicKey = poolPositionInfo.era;
+        this.ownerAccount = poolPositionInfo.ownerAccount;
+        this.deposit = poolPositionInfo.deposit.toNumber();
+        this.closedUsdh = poolPositionInfo.closedUsdh.toNumber();
+        this.timestampOpened = poolPositionInfo.timestampOpened.toNumber();
+        this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
+        this.productSnapshotEntry = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.productSnapshotEntry);
+        this.productSnapshotClosed = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.productSnapshotClosed);
+        this.sumSnapshotsEntry = poolPositionInfo.sumSnapshotsEntry.map((sum) => { return (0, HedgeDecimal_1.DecimalFromU128)(sum); });
+        this.sumSnapshotsClosed = poolPositionInfo.sumSnapshotsClosed.map((sum) => { return (0, HedgeDecimal_1.DecimalFromU128)(sum); });
+        this.hedgeRewardsSnapshot = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.hedgeRewardsSnapshotAccum);
+        this.open = poolPositionInfo.state.open !== undefined;
+    }
+    getUsdhAvailable(era) {
+        return (era.product.div(this.productSnapshotEntry)).mul(new decimal_js_1.default(this.deposit));
+    }
+    getTokensAvailable(era, index) {
+        return era.sum[index].minus(this.sumSnapshotsEntry[index]).div(this.productSnapshotEntry).mul(new decimal_js_1.default(this.deposit)).floor();
+    }
+}
+exports.LiquidationPosition = LiquidationPosition;
+// 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/lib/state/StakingPool.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingPool = void 0;
+const HedgeDecimal_1 = require("../HedgeDecimal");
+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 = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.hedgeRewardAccumulator);
+        this.usdhFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.usdhFeeAccumulator);
+        this.solFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.solFeeAccumulator);
+        // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
+    }
+}
+exports.StakingPool = StakingPool;

package/lib/state/StakingPoolPosition.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StakingPoolPosition = void 0;
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+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 = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startHedgeRewardAccumulator);
+        this.startUsdhFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startUsdhFeeAccumulator);
+        this.startSolFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startSolFeeAccumulator);
+        this.open = poolPositionInfo.state.open !== undefined;
+    }
+    getCurrentUsdhFeeReward() {
+        return this.pool.usdhFeeAccumulator.minus(this.startUsdhFeeAccumulator).times(new decimal_js_1.default(this.deposited));
+    }
+}
+exports.StakingPoolPosition = StakingPoolPosition;