hedge-web3 0.1.13 → 0.1.16

package/lib/instructions/claimLiquidationPoolPosition.js

@@ -0,0 +1,53 @@
+"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.claimLiquidationPoolPositionInstruction = exports.claimLiquidationPoolPosition = void 0;
+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 claimLiquidationPoolPosition(program, provider, poolPosition, payer, collateralType, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(collateralType);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const collateralMint = vaultTypeAccountInfo.collateralMint;
+        const poolStatePublicKey = yield (0, Constants_1.getLiquidationPoolStatePublicKey)();
+        const poolAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolStatePublicKey, collateralMint);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, payer.publicKey);
+        const transaction = new web3_js_1.Transaction().add(yield claimLiquidationPoolPositionInstruction(program, poolStatePublicKey, poolAssociatedTokenAccount, vaultTypeAccountPublicKey, collateralMint, poolPosition, payer.publicKey, payerAssociatedTokenAccount.address, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return payerAssociatedTokenAccount.address;
+    });
+}
+exports.claimLiquidationPoolPosition = claimLiquidationPoolPosition;
+function claimLiquidationPoolPositionInstruction(program, poolState, poolAssociatedTokenAccount, vaultTypeAccount, collateralMint, poolPosition, payer, payerAssociatedTokenAccount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        return program.instruction.claimLiquidationPoolPosition({
+            accounts: {
+                vaultSystemState: vaultSystemState,
+                poolState: poolState,
+                poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+                vaultTypeAccount: vaultTypeAccount,
+                collateralMint: collateralMint,
+                poolPosition: poolPosition,
+                payer: payer,
+                payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+                associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+            },
+            signers: []
+        });
+    });
+}
+exports.claimLiquidationPoolPositionInstruction = claimLiquidationPoolPositionInstruction;

package/lib/instructions/closeLiquidationPoolPosition.js

@@ -0,0 +1,60 @@
+"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.closeLiquidationPoolPositionInstruction = exports.closeLiquidationPoolPosition = 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 closeLiquidationPoolPosition(program, provider, poolPosition, payer, overrideStartTime) {
+    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 poolState = yield (0, Constants_1.getLiquidationPoolStatePublicKey)();
+        const liquidationPositionAccount = yield program.account.liquidationPosition.fetch(poolPosition);
+        const poolEra = liquidationPositionAccount.era;
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const poolUsdhAccount = yield (0, Constants_1.getLiquidationPoolUsdhAccountPublicKey)();
+        const hedgeMint = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const payerAssociatedHedgeAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, hedgeMint, payer.publicKey);
+        const communityAssociatedHedgeTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, hedgeMint, vaultSystemStatePublicKey, true);
+        const transaction = new web3_js_1.Transaction().add(yield closeLiquidationPoolPositionInstruction(program, vaultSystemStatePublicKey, poolState, poolEra, poolPosition, poolUsdhAccount, payer.publicKey, payerUsdhAccount.address, hedgeMint, payerAssociatedHedgeAccount.address, communityAssociatedHedgeTokenAccount.address, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return poolPosition;
+    });
+}
+exports.closeLiquidationPoolPosition = closeLiquidationPoolPosition;
+function closeLiquidationPoolPositionInstruction(program, vaultSystemState, poolState, poolEra, poolPosition, poolUsdhAccount, payerPublicKey, payerUsdhAccount, hedgeMint, payerAssociatedHedgeAccount, communityAssociatedHedgeTokenAccount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return program.instruction.closeLiquidationPoolPosition(new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemState,
+                poolState: poolState,
+                poolEra: poolEra,
+                poolPosition: poolPosition,
+                poolUsdhAccount: poolUsdhAccount,
+                payer: payerPublicKey,
+                ownerUsdhAccount: payerUsdhAccount,
+                hedgeMint: hedgeMint,
+                payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+                communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccount,
+                associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+            },
+            signers: []
+        });
+    });
+}
+exports.closeLiquidationPoolPositionInstruction = closeLiquidationPoolPositionInstruction;

package/lib/instructions/createStakingPool.js

@@ -0,0 +1,52 @@
+"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.createStakingPoolInstruction = exports.createStakingPool = 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 createStakingPool(program, provider, payer, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const transaction = new web3_js_1.Transaction().add(yield createStakingPoolInstruction(program, payer.publicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts).catch(Errors_1.parseAnchorErrors);
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(mintPublicKey);
+        return poolPublickey;
+    });
+}
+exports.createStakingPool = createStakingPool;
+function createStakingPoolInstruction(program, payerPublicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const [poolPublickey, poolBump, poolSeedPhrase] = yield (0, Constants_1.getPoolPublicKeyForMint)(mintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, mintPublicKey);
+        const poolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, usdhMintPublickey);
+        return program.instruction.createStakingPool(poolBump, poolSeedPhrase, new anchor_1.BN(hedgeTokensToBeMinted), new anchor_1.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_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.createStakingPoolInstruction = createStakingPoolInstruction;

package/lib/instructions/createVault.js

@@ -0,0 +1,92 @@
+"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.createVaultInstruction = exports.createVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const serum_1 = require("@project-serum/serum");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const uuid_1 = require("uuid");
+const Errors_1 = require("../utils/Errors");
+function createVault(program, provider, payer, collateralType, depositAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const salt = (0, uuid_1.v4)().substring(0, 8);
+        const newVaultPublicKey = yield (0, Constants_1.findVaultAddress)(salt);
+        const history = web3_js_1.Keypair.generate();
+        // Prep the user to get USDH back out at some point
+        yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, usdhMintPublickey, payer.publicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(collateralType);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const payerTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payer.publicKey, vaultTypeAccountInfo.collateralMint);
+        const vaultAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(newVaultPublicKey, vaultTypeAccountInfo.collateralMint);
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const wrappedSolAccount = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction();
+        const signers = [payer, history];
+        const isWrappedSol = vaultTypeAccountInfo.collateralMint.toString() === serum_1.TokenInstructions.WRAPPED_SOL_MINT.toString();
+        const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(yield (0, Constants_1.getHedgeMintPublicKey)());
+        const feePoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
+        if (isWrappedSol) {
+            transaction.add(web3_js_1.SystemProgram.createAccount({
+                fromPubkey: payer.publicKey,
+                lamports: depositAmount + 2.04e6,
+                newAccountPubkey: wrappedSolAccount.publicKey,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+                space: 165
+            }), serum_1.TokenInstructions.initializeAccount({
+                account: wrappedSolAccount.publicKey,
+                mint: serum_1.TokenInstructions.WRAPPED_SOL_MINT,
+                owner: payer.publicKey
+            }));
+            signers.push(wrappedSolAccount);
+        }
+        transaction.add(yield createVaultInstruction(program, salt, vaultSystemStatePublicKey, payer.publicKey, isWrappedSol ? wrappedSolAccount.publicKey : payerTokenAccount, newVaultPublicKey, vaultAssociatedTokenAccount, hedgeStakingPoolPublicKey, feePoolAssociatedUsdhTokenAccount, vaultTypeAccountPublicKey, vaultTypeAccountInfo.collateralMint, history.publicKey, usdhMintPublickey, depositAmount, overrideTime));
+        if (isWrappedSol) {
+            transaction.add(serum_1.TokenInstructions.closeAccount({
+                source: wrappedSolAccount.publicKey,
+                destination: payer.publicKey,
+                owner: payer.publicKey
+            }));
+        }
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, signers, provider === null || provider === void 0 ? void 0 : provider.opts).catch(Errors_1.parseAnchorErrors);
+        return newVaultPublicKey;
+    });
+}
+exports.createVault = createVault;
+function createVaultInstruction(program, salt, vaultSystemStatePublicKey, payerPublicKey, payerTokenAccountPublicKey, vaultPublicKey, vaultAssociatedTokenAccount, feePool, feePoolAssociatedUsdhTokenAccount, vaultTypeAccount, collateralMint, historyPublicKey, usdhMintPublickey, depositAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ix = program.instruction.createVault(salt, new anchor_1.BN(depositAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccount,
+                vault: vaultPublicKey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                feePool: feePool,
+                feePoolAssociatedUsdhTokenAccount: feePoolAssociatedUsdhTokenAccount,
+                history: historyPublicKey,
+                payer: payerPublicKey,
+                payerTokenAccount: payerTokenAccountPublicKey,
+                collateralMint: collateralMint,
+                usdhMint: usdhMintPublickey,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+            },
+            signers: []
+        });
+        return ix;
+    });
+}
+exports.createVaultInstruction = createVaultInstruction;

package/lib/instructions/depositLiquidationPool.js

@@ -0,0 +1,55 @@
+"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.depositLiquidationPoolInstruction = exports.depositLiquidationPool = 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 depositLiquidationPool(program, provider, payer, depositAmount, overrideStartTime) {
+    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 poolPosition = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield depositLiquidationPoolInstruction(program, payer.publicKey, payerUsdhAccount.address, poolPosition.publicKey, depositAmount, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return poolPosition.publicKey;
+    });
+}
+exports.depositLiquidationPool = depositLiquidationPool;
+function depositLiquidationPoolInstruction(program, payerPublicKey, payerUsdhAccount, poolPositionPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const liquidationPoolStatePublicKey = yield (0, Constants_1.getLiquidationPoolStatePublicKey)();
+        const liquidationPoolState = yield program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+        const poolUSDHAccount = yield (0, Constants_1.getLiquidationPoolUsdhAccountPublicKey)();
+        const usdhMint = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        return program.instruction.depositLiquidationPool(new anchor_1.BN(depositAmount), new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemState,
+                poolState: liquidationPoolStatePublicKey,
+                poolEra: liquidationPoolState.currentEra,
+                poolPosition: poolPositionPublicKey,
+                poolUsdhAccount: poolUSDHAccount,
+                usdhMint: usdhMint,
+                payer: payerPublicKey,
+                ownerUsdhAccount: payerUsdhAccount,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY
+            },
+            signers: []
+        });
+    });
+}
+exports.depositLiquidationPoolInstruction = depositLiquidationPoolInstruction;

package/lib/instructions/depositStakingPool.js

@@ -0,0 +1,52 @@
+"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.depositStakingPoolInstruction = exports.depositStakingPool = 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 depositStakingPool(program, provider, payer, mintPublicKey, depositAmount, 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 depositStakingPoolInstruction(program, payer.publicKey, poolPosition.publicKey, mintPublicKey, depositAmount, overrideStartTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return poolPosition.publicKey;
+    });
+}
+exports.depositStakingPool = depositStakingPool;
+function depositStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(stakedTokenMintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, stakedTokenMintPublicKey);
+        const payersArbitraryTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, stakedTokenMintPublicKey);
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        return program.instruction.depositStakingPool(new anchor_1.BN(depositAmount), new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+        {
+            accounts: {
+                payer: payerPublicKey,
+                vaultSystemState: vaultSystemState,
+                pool: poolPublickey,
+                poolPosition: poolPositionPublicKey,
+                stakedTokenMintInfo: stakedTokenMintPublicKey,
+                poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+                payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+                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.depositStakingPoolInstruction = depositStakingPoolInstruction;

package/lib/instructions/depositVault.js

@@ -0,0 +1,87 @@
+"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.depositVaultInstruction = exports.depositVault = void 0;
+const anchor_1 = require("@project-serum/anchor");
+const serum_1 = require("@project-serum/serum");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function depositVault(program, provider, payer, vaultPublicKey, depositAmount, 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 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 payerTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payer.publicKey, vaultTypeAccountInfo.collateralMint);
+        const vaultAssociatedCollateralAccountPublicKey = yield (0, Constants_1.findAssociatedTokenAddress)(vaultPublicKey, vaultTypeAccountInfo.collateralMint);
+        const history = web3_js_1.Keypair.generate();
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const wrappedSolAccount = web3_js_1.Keypair.generate();
+        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();
+        const signers = [payer, history];
+        if (vaultAccount.collateralType === 'SOL') {
+            transaction.add(web3_js_1.SystemProgram.createAccount({
+                fromPubkey: payer.publicKey,
+                lamports: depositAmount + 2.04e6,
+                newAccountPubkey: wrappedSolAccount.publicKey,
+                programId: spl_token_1.TOKEN_PROGRAM_ID,
+                space: 165
+            }), serum_1.TokenInstructions.initializeAccount({
+                account: wrappedSolAccount.publicKey,
+                mint: serum_1.TokenInstructions.WRAPPED_SOL_MINT,
+                owner: payer.publicKey
+            }));
+            signers.push(wrappedSolAccount);
+        }
+        transaction.add(yield depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultAccount.collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount, vaultPublicKey, vaultAssociatedCollateralAccountPublicKey, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUsdhTokenAccount, vaultTypeAccountInfo.collateralMint, usdhMintPublickey, depositAmount, overrideTime));
+        if (vaultAccount.collateralType === 'SOL') {
+            transaction.add(serum_1.TokenInstructions.closeAccount({
+                source: wrappedSolAccount.publicKey,
+                destination: payer.publicKey,
+                owner: payer.publicKey
+            }));
+        }
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, signers, provider.opts);
+        return vaultPublicKey;
+    });
+}
+exports.depositVault = depositVault;
+function depositVaultInstruction(program, vaultSystemStatePublicKey, vaultOwner, vaultOwnerTokenAccount, vaultPublicKey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUsdhTokenAccount, collateralMint, usdhMintPublickey, depositAmount, overrideTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return program.instruction.depositVault(new anchor_1.BN(depositAmount), new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
+        {
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultTypeAccount: vaultTypeAccountPublicKey,
+                vaultTypeAssociatedTokenAccount: vaultTypeAssociatedTokenAccount,
+                collateralTokenMint: collateralMint,
+                vault: vaultPublicKey,
+                vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+                feePool: hedgeStakingPoolPublicKey,
+                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+                history: historyPublicKey,
+                vaultOwner: vaultOwner,
+                vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+                usdhMint: usdhMintPublickey,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+            },
+            signers: []
+        });
+    });
+}
+exports.depositVaultInstruction = depositVaultInstruction;

package/lib/instructions/initHedgeFoundation.js

@@ -0,0 +1,55 @@
+"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.initHedgeFoundationInstruction = exports.initHedgeFoundation = void 0;
+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 initHedgeFoundation(program, provider, payer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const poolEra = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield initHedgeFoundationInstruction(program, poolEra.publicKey, payer.publicKey));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, poolEra], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return payer.publicKey;
+    });
+}
+exports.initHedgeFoundation = initHedgeFoundation;
+function initHedgeFoundationInstruction(program, poolEraPublicKey, payerPublicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const poolStatePublickey = yield (0, Constants_1.getLiquidationPoolStatePublicKey)();
+        const poolUsdhTokenAccount = yield (0, Constants_1.getLiquidationPoolUsdhAccountPublicKey)();
+        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const founderHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, hedgeMintPublickey);
+        const communityHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultSystemStatePublicKey, hedgeMintPublickey);
+        return program.instruction.initHedgeFoundation({
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                poolState: poolStatePublickey,
+                poolEra: poolEraPublicKey,
+                poolUsdhAccount: poolUsdhTokenAccount,
+                founder: payerPublicKey,
+                usdhMint: usdhMintPublickey,
+                hedgeMint: hedgeMintPublickey,
+                founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
+                communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+                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.initHedgeFoundationInstruction = initHedgeFoundationInstruction;

package/lib/instructions/initHedgeFoundationTokens.js

@@ -0,0 +1,48 @@
+"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.initHedgeFoundationTokensInstruction = exports.initHedgeFoundationTokens = void 0;
+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 initHedgeFoundationTokens(program, provider, payer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const poolEra = web3_js_1.Keypair.generate();
+        const transaction = new web3_js_1.Transaction().add(yield initHedgeFoundationTokensInstruction(program, payer.publicKey));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer], provider.opts).catch(Errors_1.parseAnchorErrors);
+        return payer.publicKey;
+    });
+}
+exports.initHedgeFoundationTokens = initHedgeFoundationTokens;
+function initHedgeFoundationTokensInstruction(program, payerPublicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
+        const founderHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, hedgeMintPublickey);
+        const communityHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultSystemStatePublicKey, hedgeMintPublickey);
+        return program.instruction.initHedgeFoundationTokens({
+            accounts: {
+                vaultSystemState: vaultSystemStatePublicKey,
+                founder: payerPublicKey,
+                hedgeMint: hedgeMintPublickey,
+                founderAssociatedHedgeTokenAccount: founderHedgeTokenAccount,
+                communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
+                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.initHedgeFoundationTokensInstruction = initHedgeFoundationTokensInstruction;