hedge-web3 0.1.26 → 0.1.29

package/lib/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./instructions/refreshOraclePrice"), exports);
 __exportStar(require("./instructions/initHedgeFoundation"), exports);
 __exportStar(require("./instructions/initHedgeFoundationTokens"), exports);
 __exportStar(require("./instructions/setHalted"), exports);
+__exportStar(require("./instructions/setVaultTypeStatus"), exports);
 __exportStar(require("./HedgeDecimal"), exports);
 __exportStar(require("./Constants"), exports);
 __exportStar(require("./state/VaultAccount"), exports);
@@ -37,3 +38,4 @@ __exportStar(require("./state/StakingPoolPosition"), exports);
 __exportStar(require("./state/LiquidationPoolEra"), exports);
 __exportStar(require("./state/LiquidationPoolState"), exports);
 __exportStar(require("./state/LiquidationPosition"), exports);
+__exportStar(require("./utils/getLinkedListAccounts"), exports);

package/lib/instructions/createStakingPool.js

@@ -29,10 +29,10 @@ function createStakingPoolInstruction(program, payerPublicKey, mintPublicKey, he
         console.log("createStakingPoolInstruction program ID", program.programId.toString());
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
-        const [poolPublickey, poolBump, poolSeedPhrase] = yield (0, Constants_1.getPoolPublicKeyForMint)(mintPublicKey);
+        const [poolPublickey, poolBump] = yield (0, Constants_1.getPoolPublicKeyForMint)(mintPublicKey);
         const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, mintPublicKey);
         const poolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, ushMintPublickey);
-        return program.instruction.createStakingPool(poolBump, poolSeedPhrase, new anchor_1.BN(hedgeTokensToBeMinted), new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)), {
+        return program.instruction.createStakingPool(poolBump, new anchor_1.BN(hedgeTokensToBeMinted), new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)), {
             accounts: {
                 signer: payerPublicKey,
                 vaultSystemState: vaultSystemStatePublicKey,

package/lib/instructions/depositVault.js

@@ -14,6 +14,7 @@ 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 getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const Constants_1 = require("../Constants");
 function depositVault(program, provider, payer, vaultPublicKey, depositAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -33,26 +34,29 @@ function depositVault(program, provider, payer, vaultPublicKey, depositAmount, o
         const hedgeStakingPoolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, ushMintPublickey);
         const transaction = new web3_js_1.Transaction();
         const signers = [payer, history];
+        const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, depositAmount, 0, false, false);
         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
+                space: 165,
             }), serum_1.TokenInstructions.initializeAccount({
                 account: wrappedSolAccount.publicKey,
                 mint: serum_1.TokenInstructions.WRAPPED_SOL_MINT,
-                owner: payer.publicKey
+                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, hedgeStakingPoolAssociatedUshTokenAccount, vaultTypeAccountInfo.collateralMint, ushMintPublickey, depositAmount, overrideTime));
+        transaction.add(yield depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultAccount.collateralType === 'SOL'
+            ? wrappedSolAccount.publicKey
+            : payerTokenAccount, vaultPublicKey, vaultAssociatedCollateralAccountPublicKey, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, vaultTypeAccountInfo.collateralMint, ushMintPublickey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, depositAmount, overrideTime));
         if (vaultAccount.collateralType === 'SOL') {
             transaction.add(serum_1.TokenInstructions.closeAccount({
                 source: wrappedSolAccount.publicKey,
                 destination: payer.publicKey,
-                owner: payer.publicKey
+                owner: payer.publicKey,
             }));
         }
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, signers, provider.opts);
@@ -60,7 +64,7 @@ function depositVault(program, provider, payer, vaultPublicKey, depositAmount, o
     });
 }
 exports.depositVault = depositVault;
-function depositVaultInstruction(program, vaultSystemStatePublicKey, vaultOwner, vaultOwnerTokenAccount, vaultPublicKey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, ushMintPublickey, depositAmount, overrideTime) {
+function depositVaultInstruction(program, vaultSystemStatePublicKey, vaultOwner, vaultOwnerTokenAccount, vaultPublicKey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, ushMintPublickey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, 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
         {
@@ -77,10 +81,13 @@ function depositVaultInstruction(program, vaultSystemStatePublicKey, vaultOwner,
                 vaultOwner: vaultOwner,
                 vaultOwnerTokenAccount: vaultOwnerTokenAccount,
                 ushMint: ushMintPublickey,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 systemProgram: web3_js_1.SystemProgram.programId,
-                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
             },
-            signers: []
+            signers: [],
         });
     });
 }

package/lib/instructions/liquidateVault.js

@@ -13,6 +13,7 @@ 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 getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const Constants_1 = require("../Constants");
 function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -31,16 +32,17 @@ function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime)
         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 hedgeStakingPoolAssociatedUshTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, hedgeStakingPoolPublicKey, true);
+        const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, 0, 0, false, 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, hedgeStakingPoolAssociatedUshTokenAccount.address, collateralMint, vaultTypeAssociatedTokenAccount.address, vaultAccount.collateralType, overrideTime));
+        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.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, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, vaultTypeAssociatedTokenAccount, collateralType, overrideTime) {
+function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, poolState, poolEra, poolAssociatedTokenAccount, historyPublicKey, newEraPublicKey, feePool, feePoolAssociatedTokenAccount, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, collateralType, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -66,12 +68,15 @@ function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedToken
                 feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
                 liquidationPoolUshAccount: liquidationPoolUshAccountPublickey,
                 newEra: newEraPublicKey,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 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
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
             },
-            signers: []
+            signers: [],
         };
         return program.instruction.liquidateVault(new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
         payload);

package/lib/instructions/loanVault.js

@@ -13,6 +13,7 @@ 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 getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const Constants_1 = require("../Constants");
 function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -23,14 +24,15 @@ function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrid
         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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, 0, loanAmount, false, false);
         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, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, loanAmount, overrideTime));
+        const transaction = new web3_js_1.Transaction().add(yield loanVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, loanAmount, overrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
         return vaultPublicKey;
     });
 }
 exports.loanVault = loanVault;
-function loanVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, loanAmount, overrideTime) {
+function loanVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, loanAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -51,10 +53,13 @@ function loanVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPub
                 ushMint: ushMintPublickey,
                 vaultOwner: payerPublicKey,
                 ownerUshAccount: ownerUshAccount,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                systemProgram: web3_js_1.SystemProgram.programId
+                systemProgram: web3_js_1.SystemProgram.programId,
             },
-            signers: []
+            signers: [],
         });
     });
 }

package/lib/instructions/redeemVault.js

@@ -14,6 +14,7 @@ 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 getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const Constants_1 = require("../Constants");
 function redeemVault(program, provider, payer, vaultPublicKey, redeemAmount, transactionOverrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -26,14 +27,15 @@ function redeemVault(program, provider, payer, vaultPublicKey, redeemAmount, tra
         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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, 0, 0, true, false);
         const history = web3_js_1.Keypair.generate();
-        const transaction = new web3_js_1.Transaction().add(yield redeemVaultInstruction(program, payer.publicKey, payerUshAccount.address, payerTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, redeemAmount, transactionOverrideTime));
+        const transaction = new web3_js_1.Transaction().add(yield redeemVaultInstruction(program, payer.publicKey, payerUshAccount.address, payerTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, redeemAmount, transactionOverrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
         return vaultPublicKey;
     });
 }
 exports.redeemVault = redeemVault;
-function redeemVaultInstruction(program, payerPublicKey, payerUshAccount, destinationTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, redeemAmount, transactionOverrideTime) {
+function redeemVaultInstruction(program, payerPublicKey, payerUshAccount, destinationTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, redeemAmount, transactionOverrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -55,6 +57,9 @@ function redeemVaultInstruction(program, payerPublicKey, payerUshAccount, destin
                 payer: payerPublicKey,
                 payerUshAccount: payerUshAccount,
                 destinationTokenAccount: destinationTokenAccount,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 systemProgram: web3_js_1.SystemProgram.programId
             },

package/lib/instructions/repayVault.js

@@ -13,6 +13,7 @@ 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 getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 const Constants_1 = require("../Constants");
 function repayVault(program, provider, payer, vaultPublicKey, repayAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -24,14 +25,15 @@ function repayVault(program, provider, payer, vaultPublicKey, repayAmount, overr
         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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, 0, repayAmount * -1, false, false);
         const history = web3_js_1.Keypair.generate();
-        const transaction = new web3_js_1.Transaction().add(yield repayVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, repayAmount, overrideTime));
+        const transaction = new web3_js_1.Transaction().add(yield repayVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, repayAmount, overrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history], provider.opts);
         return vaultPublicKey;
     });
 }
 exports.repayVault = repayVault;
-function repayVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, repayAmount, overrideTime) {
+function repayVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, repayAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -51,11 +53,14 @@ function repayVaultInstruction(program, payerPublicKey, ownerUshAccount, vaultPu
                 feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
                 ushMint: ushMintPublickey,
                 vaultOwner: payerPublicKey,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 ownerUshAccount: ownerUshAccount,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                systemProgram: web3_js_1.SystemProgram.programId
+                systemProgram: web3_js_1.SystemProgram.programId,
             },
-            signers: []
+            signers: [],
         });
     });
 }

package/lib/instructions/setVaultTypeStatus.js

@@ -0,0 +1,38 @@
+"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.setVaultTypeStatusInstruction = exports.setVaultTypeStatus = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+const Errors_1 = require("../utils/Errors");
+function setVaultTypeStatus(program, provider, payer, vaultTypeAccount, deprecated) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const transaction = new web3_js_1.Transaction().add(yield setVaultTypeStatusInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultTypeAccount, deprecated));
+        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.setVaultTypeStatus = setVaultTypeStatus;
+function setVaultTypeStatusInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultTypeAccount, deprecated) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ix = program.instruction.setVaultTypeStatus(deprecated, {
+            accounts: {
+                payer: payerPublicKey,
+                vaultSystemState: vaultSystemStatePublicKey,
+                vaultType: vaultTypeAccount,
+            },
+            signers: []
+        });
+        return ix;
+    });
+}
+exports.setVaultTypeStatusInstruction = setVaultTypeStatusInstruction;

package/lib/instructions/withdrawVault.js

@@ -15,6 +15,7 @@ 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");
+const getLinkedListAccounts_1 = require("../utils/getLinkedListAccounts");
 function withdrawVault(program, provider, payer, vaultPublicKey, withdrawAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -23,20 +24,21 @@ function withdrawVault(program, provider, payer, vaultPublicKey, withdrawAmount,
         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 vaultTypeAccountPublicKey = 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 vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, 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 hedgeStakingPoolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, ushMintPublickey);
-        const transaction = new web3_js_1.Transaction().add(yield withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, destinationTokenAccount.address, vaultPublicKey, vaultAssociatedCollateralAccount.address, vaultTypeAccount, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, ushMintPublickey, history.publicKey, withdrawAmount, overrideTime));
+        const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, withdrawAmount * -1, 0, false, false);
+        const transaction = new web3_js_1.Transaction().add(yield withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, destinationTokenAccount.address, vaultPublicKey, vaultAssociatedCollateralAccount.address, vaultTypeAccountPublicKey, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, ushMintPublickey, history.publicKey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, 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, hedgeStakingPoolAssociatedUshTokenAccount, ushMint, historyPublicKey, withdrawAmount, overrideTime) {
+function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, destinationTokenAccount, vaultPublickey, vaultAssociatedCollateralPublicKey, vaultTypeAccount, vaultTypeAssociatedTokenAccount, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, ushMint, historyPublicKey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, 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
         {
@@ -52,10 +54,13 @@ function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPubli
                 history: historyPublicKey,
                 vaultOwner: payerPublicKey,
                 destinationTokenAccount: destinationTokenAccount,
+                oldSmallerVaultInfo: oldSmallerPublicKey,
+                newSmallerVaultInfo: newSmallerPublicKey,
+                newLargerVaultInfo: newLargerPublicKey,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
-                systemProgram: web3_js_1.SystemProgram.programId
+                systemProgram: web3_js_1.SystemProgram.programId,
             },
-            signers: []
+            signers: [],
         });
     });
 }

package/lib/state/VaultAccount.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultAccount = void 0;
 const web3_js_1 = require("@solana/web3.js");
+const decimal_js_1 = __importDefault(require("decimal.js"));
 const HedgeDecimal_1 = require("../HedgeDecimal");
 /**
  * A class that represents an on-chian vault.
@@ -10,6 +14,7 @@ class VaultAccount {
     constructor(vault, publicKey) {
         this.publicKey = publicKey;
         this.vaultOwner = vault.vaultOwner;
+        this.vaultNumber = vault.vaultNumber.toNumber();
         this.pdaSalt = vault.pdaSalt;
         this.deposited = vault.deposited.toNumber();
         this.denormalizedDebt = vault.denormalizedDebt.toNumber();
@@ -49,7 +54,55 @@ class VaultAccount {
      * @returns example: `1b6ca...azy71s`
      */
     toDisplayString() {
-        return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey.toString().substring(this.publicKey.toString().length - 6)}`;
+        return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey
+            .toString()
+            .substring(this.publicKey.toString().length - 6)}`;
+    }
+    addDebt(newNormalizedDebt, vaultTypeCompoundedInterest) {
+        const denormalizedNewDebt = newNormalizedDebt.div(vaultTypeCompoundedInterest);
+        this.denormalizedDebt += denormalizedNewDebt.toNumber();
+    }
+    addDeposit(depositAmount) {
+        this.deposited += depositAmount;
+    }
+    redeem() {
+        // TODO - Calculate actual redeem amount and adust correctly
+        this.denormalizedDebt = 0;
+        this.vaultStatus = 'initialized';
+    }
+    liquidate() {
+        // TODO - Calculate actual liquidate amount and adust correctly
+        this.denormalizedDebt = 0;
+        this.vaultStatus = 'liquidated';
+    }
+    redistribution(vaultTypeAccuntData) {
+        const debtProductCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.debtRedistributionProduct);
+        const collateralAccumulatorCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.collateralRedistributionAccumulator);
+        this.denormalizedDebt = debtProductCurrent
+            .div(this.debtProductSnapshotBytes)
+            .mul(new decimal_js_1.default(this.denormalizedDebt))
+            // .add(new Decimal(vaultTypeAccuntData.debtRedistributionError))
+            .toNumber();
+        const extraCollateralDeposited = this.denormalizedDebt *
+            collateralAccumulatorCurrent
+                .sub(this.collateralAccumulatorSnapshotBytes)
+                .toNumber();
+        this.deposited += extraCollateralDeposited;
+        this.collateralAccumulatorSnapshotBytes = collateralAccumulatorCurrent;
+        this.debtProductSnapshotBytes = debtProductCurrent;
+    }
+    toString(highlight) {
+        let arrow = '';
+        if (this.publicKey.toString() === highlight.toString()) {
+            arrow = ' <----';
+        }
+        let collateralRatio = 'Infinite';
+        if (this.denormalizedDebt > 0) {
+            collateralRatio = (this.deposited / this.denormalizedDebt).toFixed(8);
+        }
+        return `Vault(${this.vaultNumber}): ${this.publicKey
+            .toString()
+            .substring(0, 6)}. Debt: ${this.inUsd()} Collat: ${collateralRatio} ${arrow}`;
     }
 }
 exports.VaultAccount = VaultAccount;

package/lib/utils/Errors.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseAnchorErrors = void 0;
 const anchor_1 = require("@project-serum/anchor");
-const idl_1 = require("../idl/idl");
+const vault_1 = require("../idl/vault");
 function parseAnchorErrors(error) {
-    const idlErrors = (0, anchor_1.parseIdlErrors)(idl_1.vaultIdl);
+    const idlErrors = (0, anchor_1.parseIdlErrors)(vault_1.IDL);
     const parsedError = anchor_1.ProgramError.parse(error, idlErrors);
     if (parsedError !== null) {
         throw parsedError;

package/lib/utils/getLinkedListAccounts.js

@@ -0,0 +1,131 @@
+"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.getLinkedListAccounts = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+const VaultAccount_1 = require("../state/VaultAccount");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, depositAmount, loanAmount, redeem, liquidate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        // Default for null is the vault itself, so set them all to this vault
+        let oldSmallerPublicKey = vaultPublicKey;
+        let newSmallerPublicKey = vaultPublicKey;
+        let newLargerPublicKey = vaultPublicKey;
+        const thisVaultData = yield program.account.vault.fetch(vaultPublicKey);
+        const thisVault = new VaultAccount_1.VaultAccount(thisVaultData, vaultPublicKey);
+        // Load all the vaults
+        let allVaults = (yield program.account.vault
+            .all([
+        // {
+        //   memcmp: { bytes: bs58.encode(inputCollateralType), offset: 8 + 32 + 8 },
+        // },
+        ])
+            .catch((error) => {
+            console.log('error', error);
+        })) || [];
+        // Load them into our account objects
+        let vaults = allVaults.map((vault) => {
+            return new VaultAccount_1.VaultAccount(vault.account, vault.publicKey);
+        });
+        // Filter out the account that are not the same vault type
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.collateralType === vaultTypeAccount.collateralType;
+        });
+        // Filter out the accounts that are not open
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.vaultStatus === 'open';
+        });
+        // Sort them
+        vaults.sort(sortVaults);
+        // Find the location of the vault before the operation
+        let indexBefore = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexBefore = index;
+            }
+        });
+        // If we found it before, set the old smaller vault the one to the left
+        if (indexBefore > 0) {
+            oldSmallerPublicKey = vaults[indexBefore - 1].publicKey;
+        }
+        // Pretty print all the vaults before the operation
+        // console.log('Sorted open vaults before')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // If it wasn't in the list, add it now
+        if (indexBefore < 0) {
+            vaults.push(thisVault);
+            indexBefore = vaults.length - 1;
+        }
+        // Now that we know it's def in the list, iterate the list and update
+        // this vault with the opeation we're going to apply
+        const newNormalizedDebt = new decimal_js_1.default(loanAmount);
+        const vaultTypeCompoundedInterest = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccount.cumulativeRate.toString());
+        vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest);
+        vaults[indexBefore].addDeposit(depositAmount);
+        if (liquidate) {
+            vaults[indexBefore].liquidate();
+        }
+        if (redeem) {
+            vaults[indexBefore].redeem();
+        }
+        vaults[indexBefore].redistribution(vaultTypeAccount);
+        if (vaults[indexBefore].denormalizedDebt === 0) {
+            vaults.splice(indexBefore, 1);
+        }
+        // Sort it again since we've changed one vault
+        vaults = vaults.sort(sortVaults);
+        // Pretty print the list again
+        // console.log('Sorted open vaults with new debt added')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // Search for the vaults new position
+        let indexAfter = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexAfter = index;
+            }
+        });
+        // Print where it moved from / to
+        // console.log('Index Before', indexBefore)
+        // console.log('Index After', indexAfter)
+        // Save references to the new left and right
+        if (indexAfter > 0) {
+            newSmallerPublicKey = vaults[indexAfter - 1].publicKey;
+        }
+        if (indexAfter < vaults.length - 1 && indexAfter >= 0) {
+            newLargerPublicKey = vaults[indexAfter + 1].publicKey;
+        }
+        // Print out the new left/right
+        // console.log('oldSmallerPublicKey', oldSmallerPublicKey.toString())
+        // console.log('newSmallerPublicKey', newSmallerPublicKey.toString())
+        // console.log('newLargerPublicKey', newLargerPublicKey.toString())
+        return [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey];
+    });
+}
+exports.getLinkedListAccounts = getLinkedListAccounts;
+// Sort function we can use to sort the vaults
+// Sorted by collateral ratio. If two are the same, newer vault first
+function sortVaults(a, b) {
+    const aRatio = a.deposited / a.denormalizedDebt;
+    const bRatio = b.deposited / b.denormalizedDebt;
+    if (aRatio === bRatio) {
+        return b.vaultNumber - a.vaultNumber;
+    }
+    return aRatio - bRatio;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedge-web3",
-  "version": "0.1.26",
+  "version": "0.1.29",
   "description": "Hedge Javascript Web3 API",
   "main": "lib/index.js",
   "types": "declarations/index.d.ts",
@@ -21,6 +21,7 @@
     "@solana/spl-token": "^0.2.0",
     "@solana/web3.js": "^1.37.0",
     "@types/bn.js": "^5.1.0",
+    "@types/underscore": "^1.11.4",
     "@types/uuid": "^8.3.4",
     "bn.js": "^5.2.0",
     "decimal.js": "^10.3.1",
@@ -28,6 +29,7 @@
     "ts-standard": "^11.0.0",
     "typedoc": "^0.22.10",
     "typescript": "^4.5.5",
+    "underscore": "^1.13.2",
     "uuid": "^8.3.2"
   }
 }