hedge-web3 0.2.27 → 0.2.31

package/lib/index.js

@@ -36,6 +36,15 @@ __exportStar(require("./instructions/refreshOraclePrice"), exports);
 __exportStar(require("./instructions/repayVault"), exports);
 __exportStar(require("./instructions/setHalted"), exports);
 __exportStar(require("./instructions/transferVault"), exports);
+__exportStar(require("./instructions/createCompoundStakingPool"), exports);
+__exportStar(require("./instructions/createCompoundStakingPoolPosition"), exports);
+__exportStar(require("./instructions/depositCompoundStakingPoolPosition"), exports);
+__exportStar(require("./instructions/withdrawCompoundStakingPoolPosition"), exports);
+__exportStar(require("./instructions/setDelegateWallet"), exports);
+__exportStar(require("./instructions/setCompoundPoolActive"), exports);
+__exportStar(require("./instructions/adminWithdrawCol"), exports);
+__exportStar(require("./instructions/adminWithdrawUsh"), exports);
+__exportStar(require("./instructions/depositRewardsToCompoundPool"), exports);
 __exportStar(require("./instructions/updateReferralAccount"), exports);
 __exportStar(require("./instructions/updateReferralState"), exports);
 __exportStar(require("./instructions/updateVaultType"), exports);

package/lib/instructions/adminWithdrawCol.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminWithdrawCollateralInstruction = exports.adminWithdrawCollateral = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function adminWithdrawCollateral(program, provider, payer, mintPublicKey, collateralType) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(program.programId, collateralType);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const stakingPoolAccountObject = yield program.account.stakingPool.fetch(poolPublickey);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, stakingPoolAccountObject.compoundPoolDelegateWallet);
+        const poolAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, vaultTypeAccountInfo.collateralMint);
+        const transaction = new web3_js_1.Transaction().add(yield adminWithdrawCollateralInstruction(program, payer.publicKey, mintPublicKey, vaultTypeAccountPublicKey));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return poolPublickey;
+    });
+}
+exports.adminWithdrawCollateral = adminWithdrawCollateral;
+function adminWithdrawCollateralInstruction(program, payerPublicKey, stakedTokenMintPublicKey, vaultTypeAccountPublicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, stakedTokenMintPublicKey);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const stakingPoolAccountObject = yield program.account.stakingPool.fetch(poolPublickey);
+        const poolAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, vaultTypeAccountInfo.collateralMint);
+        const delegateAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, stakingPoolAccountObject.compoundPoolDelegateWallet, vaultTypeAccountInfo.collateralMint);
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        return yield program.methods
+            .adminWithdrawColAta()
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemState,
+            pool: poolPublickey,
+            vaultTypeAccount: vaultTypeAccountPublicKey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+            delegateAssociatedColAccount: delegateAssociatedTokenAccount,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    });
+}
+exports.adminWithdrawCollateralInstruction = adminWithdrawCollateralInstruction;

package/lib/instructions/adminWithdrawUsh.js

@@ -0,0 +1,57 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminWithdrawUshInstruction = exports.adminWithdrawUsh = void 0;
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function adminWithdrawUsh(program, provider, payer, mintPublicKey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const stakingPoolAccountObject = yield program.account.stakingPool.fetch(poolPublickey);
+        const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)(program.programId);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, stakingPoolAccountObject.compoundPoolDelegateWallet);
+        const transaction = new web3_js_1.Transaction().add(yield adminWithdrawUshInstruction(program, payer.publicKey, mintPublicKey, poolPublickey));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return poolPublickey;
+    });
+}
+exports.adminWithdrawUsh = adminWithdrawUsh;
+function adminWithdrawUshInstruction(program, payerPublicKey, stakedTokenMintPublicKey, poolPublickey) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)(program.programId);
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, ushMintPublickey);
+        const stakingPoolAccountObject = yield program.account.stakingPool.fetch(poolPublickey);
+        const delegateWalletAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, stakingPoolAccountObject.compoundPoolDelegateWallet, ushMintPublickey);
+        return yield program.methods
+            .adminWithdrawUshAta()
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemState,
+            pool: poolPublickey,
+            ushMint: ushMintPublickey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            poolAssociatedTokenAccount: poolAssociatedStakedTokenAccount,
+            delegateAssociatedUshAccount: delegateWalletAssociatedStakedTokenAccount,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    });
+}
+exports.adminWithdrawUshInstruction = adminWithdrawUshInstruction;

package/lib/instructions/createCompoundStakingPool.js

@@ -0,0 +1,58 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompoundStakingPoolInstruction = exports.createCompoundStakingPool = 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");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function createCompoundStakingPool(program, provider, payer, mintPublicKey, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const transaction = new web3_js_1.Transaction().add(yield createCompoundStakingPoolInstruction(program, payer.publicKey, mintPublicKey, overrideStartTime));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        return poolPublickey;
+    });
+}
+exports.createCompoundStakingPool = createCompoundStakingPool;
+function createCompoundStakingPoolInstruction(program, payerPublicKey, mintPublicKey, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)(program.programId);
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)(program.programId);
+        const [poolPublickey, poolBump] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, mintPublicKey);
+        const poolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, ushMintPublickey);
+        return yield program.methods
+            .createCompoundStakingPool(new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)))
+            .accounts({
+            signer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublickey,
+            stakedTokenMint: mintPublicKey,
+            ushMint: ushMintPublickey,
+            hedgeMint: hedgeMintPublickey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
+            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,
+        })
+            .instruction();
+    });
+}
+exports.createCompoundStakingPoolInstruction = createCompoundStakingPoolInstruction;

package/lib/instructions/createCompoundStakingPoolPosition.js

@@ -0,0 +1,56 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCompoundStakingPoolPositionInstruction = exports.createCompoundStakingPoolPosition = 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");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function createCompoundStakingPoolPosition(program, provider, payer, mintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey, poolBump] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const poolPosition = yield (0, Constants_1.getCompoundPoolPositionAddress)(program.programId, poolPublickey, payer.publicKey);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, mintPublicKey, payer.publicKey);
+        const transaction = new web3_js_1.Transaction().add(yield createCompoundStakingPoolPositionInstruction(program, payer.publicKey, poolPosition, mintPublicKey, new anchor_1.BN(depositAmount), overrideStartTime));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return poolPosition;
+    });
+}
+exports.createCompoundStakingPoolPosition = createCompoundStakingPoolPosition;
+function createCompoundStakingPoolPositionInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, stakedTokenMintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, stakedTokenMintPublicKey);
+        const payersArbitraryTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, payerPublicKey, stakedTokenMintPublicKey);
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        return yield program.methods
+            .createCompoundStakingPoolPosition(depositAmount, new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)) // override current time
+        )
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemState,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    });
+}
+exports.createCompoundStakingPoolPositionInstruction = createCompoundStakingPoolPositionInstruction;

package/lib/instructions/createReferralAccount.js

@@ -31,7 +31,7 @@ const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfi
  * - referrer: PublicKey
  * - overrideTime?: number
  */
-function createReferralAccount(program, provider, payer, poolPosition, overrideTime) {
+function createReferralAccount(program, provider, payer, poolPosition, stakedTokenMintPublicKey, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         // setup transaction
         const transaction = new web3_js_1.Transaction();
@@ -49,15 +49,16 @@ function createReferralAccount(program, provider, payer, poolPosition, overrideT
         const payerHdgAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, hedgeMintPublicKey, payer.publicKey);
         // Derive the user referral account public key
         const userReferralAccountPublicKey = yield (0, Constants_1.getUserReferralAccountPublicKey)(program.programId, payer.publicKey);
-        transaction.add(yield createReferralAccountInstruction(program, payer.publicKey, poolPosition, referralAccountPublicKey, referallStatePublicKey, hedgeMintPublicKey, payerHdgAssociatedTokenAccount.address, userReferralAccountPublicKey, overrideTime));
+        transaction.add(yield createReferralAccountInstruction(program, payer.publicKey, poolPosition, stakedTokenMintPublicKey, referralAccountPublicKey, referallStatePublicKey, hedgeMintPublicKey, payerHdgAssociatedTokenAccount.address, userReferralAccountPublicKey, overrideTime));
         yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, signers).catch(Errors_1.parseAnchorErrors);
         return referralAccountPublicKey;
     });
 }
 exports.createReferralAccount = createReferralAccount;
-function createReferralAccountInstruction(program, payerPublicKey, poolPositionPublicKey, referralAccountPublicKey, referralStatePublicKey, hedgeMintPublicKey, hdgAssociatedTokenAccountPublicKey, userReferralAccountPublicKey, overrideTime) {
+function createReferralAccountInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, referralAccountPublicKey, referralStatePublicKey, hedgeMintPublicKey, hdgAssociatedTokenAccountPublicKey, userReferralAccountPublicKey, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, stakedTokenMintPublicKey);
         return yield program.methods
             .createReferralAccount(new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)) // override override times
         )
@@ -68,6 +69,8 @@ function createReferralAccountInstruction(program, payerPublicKey, poolPositionP
             referralAccount: referralAccountPublicKey,
             userReferralAccount: userReferralAccountPublicKey,
             poolPosition: poolPositionPublicKey,
+            pool: poolPublickey,
+            stakedTokenMint: stakedTokenMintPublicKey,
             hedgeMint: hedgeMintPublicKey,
             hdgAta: hdgAssociatedTokenAccountPublicKey,
             systemProgram: web3_js_1.SystemProgram.programId,

package/lib/instructions/depositCompoundStakingPoolPosition.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depositCompoundStakingPoolPositionInstruction = exports.depositCompoundStakingPoolPosition = 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");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function depositCompoundStakingPoolPosition(program, provider, payer, mintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey, poolBump] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const poolPosition = yield (0, Constants_1.getCompoundPoolPositionAddress)(program.programId, poolPublickey, payer.publicKey);
+        const transaction = new web3_js_1.Transaction().add(yield depositCompoundStakingPoolPositionInstruction(program, payer.publicKey, poolPosition, mintPublicKey, new anchor_1.BN(depositAmount), overrideStartTime));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return poolPosition;
+    });
+}
+exports.depositCompoundStakingPoolPosition = depositCompoundStakingPoolPosition;
+function depositCompoundStakingPoolPositionInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, stakedTokenMintPublicKey);
+        const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, stakedTokenMintPublicKey);
+        const payersArbitraryTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, payerPublicKey, stakedTokenMintPublicKey);
+        const vaultSystemState = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        return yield program.methods
+            .depositCompoundStakingPoolPosition(depositAmount, new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)) // override current time
+        )
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemState,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    });
+}
+exports.depositCompoundStakingPoolPositionInstruction = depositCompoundStakingPoolPositionInstruction;

package/lib/instructions/depositRewardsToCompoundPool.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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depositRewardsToCompoundStakingPoolInstruction = exports.depositRewardsToCompoundStakingPool = 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");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function depositRewardsToCompoundStakingPool(program, provider, payer, mintPublicKey, depositAmount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const history = web3_js_1.Keypair.generate();
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const [poolStakingPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)(program.programId);
+        const stakingPoolAccountObject = yield program.account.stakingPool.fetch(poolStakingPublickey);
+        const payerAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, hedgeMintPublickey, stakingPoolAccountObject.compoundPoolDelegateWallet);
+        const transaction = new web3_js_1.Transaction().add(yield depositRewardsToCompoundStakingPoolInstruction(program, payer.publicKey, mintPublicKey, history.publicKey, new anchor_1.BN(depositAmount), overrideStartTime));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer, history]).catch(Errors_1.parseAnchorErrors);
+        return poolPublickey;
+    });
+}
+exports.depositRewardsToCompoundStakingPool = depositRewardsToCompoundStakingPool;
+function depositRewardsToCompoundStakingPoolInstruction(program, payerPublicKey, mintPublicKey, historyPublicKey, amount, overrideStartTime) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)(program.programId);
+        const [poolPublickey, poolBump] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const [poolStakingPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const poolAssociatedHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, poolPublickey, hedgeMintPublickey);
+        const payerAssociatedHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(program.programId, payerPublicKey, hedgeMintPublickey);
+        return yield program.methods
+            .depositRewardsToCompoundPool(amount, new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)) // override current time
+        )
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            history: historyPublicKey,
+            compoundPool: poolPublickey,
+            pool: poolStakingPublickey,
+            stakedTokenMint: mintPublicKey,
+            hedgeMint: hedgeMintPublickey,
+            poolAssociatedHedgeAccount: poolAssociatedHedgeTokenAccount,
+            payerAssociatedHedgeAccount: payerAssociatedHedgeTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .instruction();
+    });
+}
+exports.depositRewardsToCompoundStakingPoolInstruction = depositRewardsToCompoundStakingPoolInstruction;

package/lib/instructions/liquidateVault.js

@@ -29,6 +29,10 @@ function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime)
         const [hedgeStakingPoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, hedgeMintPublickey);
         const liquidationPoolStatePublicKey = yield (0, Constants_1.getLiquidationPoolStatePublicKey)(program.programId);
         const poolStateInfo = yield program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+        const additionalComputationBudget = web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 300000,
+            additionalFee: 0,
+        });
         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);
@@ -39,7 +43,9 @@ function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime)
         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, hedgeStakingPoolAssociatedUshTokenAccount.address, collateralMint, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, vaultAccount.vaultType, overrideTime));
+        transaction
+            .add(additionalComputationBudget)
+            .add(yield liquidateVaultInstruction(program, payer.publicKey, payerAssociatedTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, liquidationPoolStatePublicKey, poolStateInfo.currentEra, poolAssociatedTokenAccount.address, history.publicKey, newEra.publicKey, hedgeStakingPoolPublicKey, feePoolAssociatedTokenAccount.address, hedgeStakingPoolAssociatedUshTokenAccount.address, collateralMint, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, vaultAccount.vaultType, overrideTime));
         yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer, history, newEra]);
         return vaultPublicKey;
     });

package/lib/instructions/loanVault.js

@@ -21,6 +21,10 @@ const getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
 function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrideTime, referrer) {
     return __awaiter(this, void 0, void 0, function* () {
+        const additionalComputationBudget = web3_js_1.ComputeBudgetProgram.requestUnits({
+            units: 300000,
+            additionalFee: 0,
+        });
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)(program.programId);
         const payerUshAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, payer.publicKey);
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
@@ -37,7 +41,9 @@ function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrid
             referralAccountPublicKey = yield (0, Constants_1.getReferralAccountPublicKey)(program.programId, referrer);
         }
         const history = web3_js_1.Keypair.generate();
-        const transaction = new web3_js_1.Transaction().add(yield loanVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, new anchor_1.BN(loanAmount), referralAccountPublicKey, overrideTime));
+        const transaction = new web3_js_1.Transaction()
+            .add(additionalComputationBudget)
+            .add(yield loanVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, new anchor_1.BN(loanAmount), referralAccountPublicKey, overrideTime));
         yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer, history]);
         return vaultPublicKey;
     });

package/lib/instructions/referralClaimFees.js

@@ -29,7 +29,7 @@ const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfi
  * - poolPublicKey: PublicKey : a key to a pool position. If the position is closed or does not belong to the signer it will be ignored
  * - referrer: PublicKey
  */
-function referralClaimFees(program, provider, payer, poolPosition) {
+function referralClaimFees(program, provider, payer, poolPosition, stakedTokenMintPublicKey) {
     return __awaiter(this, void 0, void 0, function* () {
         // setup transaction
         const transaction = new web3_js_1.Transaction();
@@ -51,14 +51,15 @@ function referralClaimFees(program, provider, payer, poolPosition) {
         const communityAssociatedHedgeTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, hedgeMintPublicKey, vaultSystemStatePublicKey, true);
         const [feePoolPublicKey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, hedgeMintPublicKey);
         const feePoolAssociatedUshTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublicKey, feePoolPublicKey, true);
-        transaction.add(yield referralClaimFeesInstruction(program, payer.publicKey, vaultSystemStatePublicKey, poolPosition, referralAccountPublicKey, referallStatePublicKey, hedgeMintPublicKey, payerHdgAssociatedTokenAccount.address, ushMintPublicKey, payerUshAssociatedTokenAccount.address, communityAssociatedHedgeTokenAccount.address, feePoolPublicKey, feePoolAssociatedUshTokenAccount.address));
+        transaction.add(yield referralClaimFeesInstruction(program, payer.publicKey, vaultSystemStatePublicKey, poolPosition, stakedTokenMintPublicKey, referralAccountPublicKey, referallStatePublicKey, hedgeMintPublicKey, payerHdgAssociatedTokenAccount.address, ushMintPublicKey, payerUshAssociatedTokenAccount.address, communityAssociatedHedgeTokenAccount.address, feePoolPublicKey, feePoolAssociatedUshTokenAccount.address));
         yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, signers).catch(Errors_1.parseAnchorErrors);
         return referralAccountPublicKey;
     });
 }
 exports.referralClaimFees = referralClaimFees;
-function referralClaimFeesInstruction(program, payerPublicKey, vaultSystemStatePublicKey, poolPositionPublicKey, referralAccountPublicKey, referralStatePublicKey, hedgeMintPublicKey, hdgAssociatedTokenAccountPublicKey, ushMintPublicKey, ushAssociatedTokenAccountPublicKey, communityAssociatedHedgeTokenAccountPublicKey, feePoolPublicKey, feePoolAssociatedUshTokenAccountPublicKey) {
+function referralClaimFeesInstruction(program, payerPublicKey, vaultSystemStatePublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, referralAccountPublicKey, referralStatePublicKey, hedgeMintPublicKey, hdgAssociatedTokenAccountPublicKey, ushMintPublicKey, ushAssociatedTokenAccountPublicKey, communityAssociatedHedgeTokenAccountPublicKey, feePoolPublicKey, feePoolAssociatedUshTokenAccountPublicKey) {
     return __awaiter(this, void 0, void 0, function* () {
+        const [poolPublickey] = yield (0, Constants_1.getCompoundPoolPublicKeyForMint)(program.programId, stakedTokenMintPublicKey);
         return yield program.methods
             .referralClaimFees()
             .accounts({
@@ -72,6 +73,8 @@ function referralClaimFeesInstruction(program, payerPublicKey, vaultSystemStateP
             ushMint: ushMintPublicKey,
             signerUshAta: ushAssociatedTokenAccountPublicKey,
             communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccountPublicKey,
+            pool: poolPublickey,
+            stakedTokenMint: stakedTokenMintPublicKey,
             feePool: feePoolPublicKey,
             feePoolAssociatedUshTokenAccount: feePoolAssociatedUshTokenAccountPublicKey,
             systemProgram: web3_js_1.SystemProgram.programId,

package/lib/instructions/setCompoundPoolActive.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCompoundPoolActiveInstruction = exports.setCompoundPoolActive = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function setCompoundPoolActive(program, provider, payer, mintPublicKey, setActive) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const transaction = new web3_js_1.Transaction().add(yield setCompoundPoolActiveInstruction(program, vaultSystemStatePublicKey, payer.publicKey, poolPublickey, mintPublicKey, setActive));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return poolPublickey;
+    });
+}
+exports.setCompoundPoolActive = setCompoundPoolActive;
+function setCompoundPoolActiveInstruction(program, vaultSystemStatePublicKey, payerPublicKey, poolPublicKey, stakedTokenMintPublicKey, setActive) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield program.methods
+            .setCompoundPoolActive(setActive)
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublicKey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+        })
+            .instruction();
+    });
+}
+exports.setCompoundPoolActiveInstruction = setCompoundPoolActiveInstruction;

package/lib/instructions/setDelegateWallet.js

@@ -0,0 +1,43 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDelegateWalletInstruction = exports.setDelegateWallet = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+const sendAndConfirmWithDebug_1 = __importDefault(require("../utils/sendAndConfirmWithDebug"));
+function setDelegateWallet(program, provider, payer, mintPublicKey, delegateWallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)(program.programId);
+        const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(program.programId, mintPublicKey);
+        const transaction = new web3_js_1.Transaction().add(yield setDelegateWalletInstruction(program, vaultSystemStatePublicKey, payer.publicKey, poolPublickey, mintPublicKey, delegateWallet));
+        yield (0, sendAndConfirmWithDebug_1.default)(provider.connection, transaction, [payer]).catch(Errors_1.parseAnchorErrors);
+        return delegateWallet;
+    });
+}
+exports.setDelegateWallet = setDelegateWallet;
+function setDelegateWalletInstruction(program, vaultSystemStatePublicKey, payerPublicKey, poolPublicKey, stakedTokenMintPublicKey, delegateWallet) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield program.methods
+            .setDelegateWallet(delegateWallet)
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublicKey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+        })
+            .instruction();
+    });
+}
+exports.setDelegateWalletInstruction = setDelegateWalletInstruction;