hedge-web3 0.1.25 → 0.1.28

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/withdrawStakingPool.js

@@ -27,14 +27,14 @@ exports.withdrawStakingPool = withdrawStakingPool;
 function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
-        const usdhMintPublickey = yield (0, Constants_1.getUsdhMintPublicKey)();
+        const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
         const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
         const [poolPublickey] = yield (0, Constants_1.getPoolPublicKeyForMint)(stakedTokenMintPublicKey);
         const poolAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, stakedTokenMintPublicKey);
-        const poolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, usdhMintPublickey);
+        const poolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(poolPublickey, ushMintPublickey);
         const payerAssociatedStakedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, stakedTokenMintPublicKey);
         const payerAssociatedHedgeAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, hedgeMintPublickey);
-        const payerAssociatedUsdhAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, usdhMintPublickey);
+        const payerAssociatedUshAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payerPublicKey, ushMintPublickey);
         const communityHedgeTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultSystemStatePublicKey, hedgeMintPublickey);
         return program.instruction.withdrawStakingPool(new anchor_1.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Math.floor(Date.now() / 1000)), // override current time
         {
@@ -44,14 +44,14 @@ function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPub
                 pool: poolPublickey,
                 poolPosition: poolPositionPublicKey,
                 poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
-                poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+                poolAssociatedUshTokenAccount: poolAssociatedUshTokenAccount,
                 payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
                 payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
-                payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
+                payerAssociatedUshAccount: payerAssociatedUshAccount,
                 communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
                 hedgeMint: hedgeMintPublickey,
                 stakedTokenMint: stakedTokenMintPublicKey,
-                usdhMint: usdhMintPublickey,
+                ushMint: ushMintPublickey,
                 rent: web3_js_1.SYSVAR_RENT_PUBKEY,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
                 associatedTokenProgram: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,

package/lib/instructions/withdrawVault.js

@@ -15,28 +15,30 @@ 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 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 ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
+        // Prep the user to get USH back out at some point
+        yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, payer.publicKey);
         const history = web3_js_1.Keypair.generate();
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccount = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
+        const 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 hedgeStakingPoolAssociatedUsdhTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, usdhMintPublickey);
-        const transaction = new web3_js_1.Transaction().add(yield withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, destinationTokenAccount.address, vaultPublicKey, vaultAssociatedCollateralAccount.address, vaultTypeAccount, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUsdhTokenAccount, usdhMintPublickey, history.publicKey, withdrawAmount, overrideTime));
+        const hedgeStakingPoolAssociatedUshTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(hedgeStakingPoolPublicKey, ushMintPublickey);
+        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, hedgeStakingPoolAssociatedUsdhTokenAccount, usdhMint, 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
         {
@@ -47,15 +49,18 @@ function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPubli
                 vault: vaultPublickey,
                 vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
                 feePool: hedgeStakingPoolPublicKey,
-                feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
-                usdhMint: usdhMint,
+                feePoolAssociatedUshTokenAccount: hedgeStakingPoolAssociatedUshTokenAccount,
+                ushMint: ushMint,
                 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/LiquidationPosition.js

@@ -12,7 +12,7 @@ class LiquidationPosition {
         this.eraPublicKey = poolPositionInfo.era;
         this.ownerAccount = poolPositionInfo.ownerAccount;
         this.deposit = poolPositionInfo.deposit.toNumber();
-        this.closedUsdh = poolPositionInfo.closedUsdh.toNumber();
+        this.closedUsh = poolPositionInfo.closedUsh.toNumber();
         this.timestampOpened = poolPositionInfo.timestampOpened.toNumber();
         this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
         this.productSnapshotEntry = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.productSnapshotEntry);
@@ -23,7 +23,7 @@ class LiquidationPosition {
         this.open = poolPositionInfo.state === 1;
         console.log("poolPositionInfo.state, poolPositionInfo.state");
     }
-    getUsdhAvailable(era) {
+    getUshAvailable(era) {
         return (era.product.div(this.productSnapshotEntry)).mul(new decimal_js_1.default(this.deposit));
     }
     getTokensAvailable(era, index) {

package/lib/state/StakingPool.js

@@ -14,7 +14,7 @@ class StakingPool {
         this.halfLifeInDays = poolInfo.halfLifeInDays.toNumber();
         this.totalHedgeReward = poolInfo.totalHedgeReward.toNumber();
         this.hedgeRewardAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.hedgeRewardAccumulator);
-        this.usdhFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.usdhFeeAccumulator);
+        this.ushFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.ushFeeAccumulator);
         this.collateralFeeAccumulator = poolInfo.collateralFeeAccumulator.map((sum) => { return (0, HedgeDecimal_1.DecimalFromU128)(sum); });
         // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
     }

package/lib/state/StakingPoolPosition.js

@@ -17,12 +17,12 @@ class StakingPoolPosition {
         this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
         this.closedRewardedTokens = poolPositionInfo.closedRewardedTokens.toNumber();
         this.startHedgeRewardAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startHedgeRewardAccumulator);
-        this.startUsdhFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startUsdhFeeAccumulator);
+        this.startUshFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startUshFeeAccumulator);
         this.startSolFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolPositionInfo.startSolFeeAccumulator);
         this.open = poolPositionInfo.state.open !== undefined;
     }
-    getCurrentUsdhFeeReward() {
-        return this.pool.usdhFeeAccumulator.minus(this.startUsdhFeeAccumulator).times(new decimal_js_1.default(this.deposited));
+    getCurrentUshFeeReward() {
+        return this.pool.ushFeeAccumulator.minus(this.startUshFeeAccumulator).times(new decimal_js_1.default(this.deposited));
     }
 }
 exports.StakingPoolPosition = StakingPoolPosition;

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();
@@ -36,9 +41,9 @@ class VaultAccount {
         return this.deposited / web3_js_1.LAMPORTS_PER_SOL;
     }
     /**
-     * Get the debt value in USDH
+     * Get the debt value in USH
      *
-     * @returns debt value in USDH
+     * @returns debt value in USH
      */
     inUsd() {
         return this.denormalizedDebt / web3_js_1.LAMPORTS_PER_SOL;
@@ -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/state/VaultHistoryEvent.js

@@ -8,8 +8,8 @@ class VaultHistoryEvent {
         this.publicKey = publicKey;
         this.actorAccount = account.actorAccount;
         this.usdSolPrice = (0, HedgeDecimal_1.DecimalFromU128)(account.usdSolPrice.toString());
-        this.usdhDebtBefore = account.usdhDebtBefore.toNumber();
-        this.usdhDebtAfter = account.usdhDebtAfter.toNumber();
+        this.ushDebtBefore = account.ushDebtBefore.toNumber();
+        this.ushDebtAfter = account.ushDebtAfter.toNumber();
         this.collateralBalanceBefore = account.collateralBalanceBefore.toNumber();
         this.collateralBalanceAfter = account.collateralBalanceAfter.toNumber();
         this.minCollateralRatioBefore = (0, HedgeDecimal_1.DecimalFromU128)(account.minCollateralRatioBefore);

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.25",
+  "version": "0.1.28",
   "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"
   }
 }

package/src/Constants.ts

@@ -1,64 +1,106 @@
-import { ASSOCIATED_TOKEN_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token'
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+} from '@solana/spl-token'
 import { PublicKey } from '@solana/web3.js'
 
-export const HEDGE_PROGRAM_ID = 'h14ydGHkAt6vpBaxX461fgxGYsZjaf2K8Fqwm7Cn3ik'
+export const HEDGE_PROGRAM_ID = 'HDG3uyafYaKxSYRW37ZBTdxaUCoyzaqbuirYucAeaPFY'
 export const HEDGE_PROGRAM_PUBLICKEY = new PublicKey(HEDGE_PROGRAM_ID)
 
-export const CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'
+export const CHAINLINK_SOL_USD_ID =
+  'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'
 export const CHAINLINK_SOL_USD_PUBLICKEY = new PublicKey(CHAINLINK_SOL_USD_ID)
 
 const enc = new TextEncoder()
 
-export async function getLiquidationPoolStatePublicKey (): Promise<PublicKey> {
-  const [poolPublicKey] = await PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getLiquidationPoolStatePublicKey(): Promise<PublicKey> {
+  const [poolPublicKey] = await PublicKey.findProgramAddress(
+    [enc.encode('LiquidationPoolStateV1')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return poolPublicKey
 }
 
-export async function getLiquidationPoolUsdhAccountPublicKey (): Promise<PublicKey> {
-  const [poolPublicKey] = await PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getLiquidationPoolUshAccountPublicKey(): Promise<PublicKey> {
+  const [poolPublicKey] = await PublicKey.findProgramAddress(
+    [enc.encode('LiquidationPoolUSHAccountV1')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return poolPublicKey
 }
 
-export async function getUsdhMintPublicKey (): Promise<PublicKey> {
-  const [findMintPublicKey] = await PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getUshMintPublicKey(): Promise<PublicKey> {
+  const [findMintPublicKey] = await PublicKey.findProgramAddress(
+    [enc.encode('UshMintV1')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return findMintPublicKey
 }
 
-export async function getVaultSystemStatePublicKey (): Promise<PublicKey> {
-  const [publicKey] = await PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getVaultSystemStatePublicKey(): Promise<PublicKey> {
+  const [publicKey] = await PublicKey.findProgramAddress(
+    [enc.encode('VaultSystemStateV1')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return publicKey
 }
 
-export async function getHedgeMintPublicKey (): Promise<PublicKey> {
-  const [publicKey] = await PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getHedgeMintPublicKey(): Promise<PublicKey> {
+  const [publicKey] = await PublicKey.findProgramAddress(
+    [enc.encode('HEDGEMintV1')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return publicKey
 }
 
-export async function getPoolPublicKeyForMint (mintPublicKey: PublicKey): Promise<[PublicKey, number, string]> {
-  const strToEncode = (mintPublicKey.toString().substring(0, 12))
-  const [publicKey, bump] = await PublicKey.findProgramAddress([enc.encode(strToEncode)], HEDGE_PROGRAM_PUBLICKEY)
+export async function getPoolPublicKeyForMint(
+  mintPublicKey: PublicKey
+): Promise<[PublicKey, number, string]> {
+  const strToEncode = mintPublicKey.toString().substring(0, 12)
+  const [publicKey, bump] = await PublicKey.findProgramAddress(
+    [enc.encode(strToEncode)],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return [publicKey, bump, strToEncode]
 }
-export async function getVaultTypeAccountPublicKey (collateralType: string): Promise<PublicKey> {
-  const [vaultTypeAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getVaultTypeAccountPublicKey(
+  collateralType: string
+): Promise<PublicKey> {
+  const [vaultTypeAccount] = await PublicKey.findProgramAddress(
+    [enc.encode(collateralType), enc.encode('State')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return vaultTypeAccount
 }
-export async function getVaultTypeOracleAccountPublicKey (collateralType: string): Promise<PublicKey> {
-  const [vaultTypeOracleAccount] = await PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY)
+export async function getVaultTypeOracleAccountPublicKey(
+  collateralType: string
+): Promise<PublicKey> {
+  const [vaultTypeOracleAccount] = await PublicKey.findProgramAddress(
+    [enc.encode(collateralType), enc.encode('Oracle')],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return vaultTypeOracleAccount
 }
-export async function findVaultAddress (vaultSalt: string): Promise<PublicKey> {
-  const [vaultAddress] = await PublicKey.findProgramAddress([enc.encode('Vault'), enc.encode(vaultSalt)], HEDGE_PROGRAM_PUBLICKEY)
+export async function findVaultAddress(vaultSalt: string): Promise<PublicKey> {
+  const [vaultAddress] = await PublicKey.findProgramAddress(
+    [enc.encode('Vault'), enc.encode(vaultSalt)],
+    HEDGE_PROGRAM_PUBLICKEY
+  )
   return vaultAddress
 }
 
-export async function findAssociatedTokenAddress (walletAddress: PublicKey, tokenMintAddress: PublicKey): Promise<PublicKey> {
-  return (await PublicKey.findProgramAddress(
-    [
-      walletAddress.toBuffer(),
-      TOKEN_PROGRAM_ID.toBuffer(),
-      tokenMintAddress.toBuffer()
-    ],
-    ASSOCIATED_TOKEN_PROGRAM_ID
-  ))[0]
+export async function findAssociatedTokenAddress(
+  walletAddress: PublicKey,
+  tokenMintAddress: PublicKey
+): Promise<PublicKey> {
+  return (
+    await PublicKey.findProgramAddress(
+      [
+        walletAddress.toBuffer(),
+        TOKEN_PROGRAM_ID.toBuffer(),
+        tokenMintAddress.toBuffer(),
+      ],
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    )
+  )[0]
 }