hedge-web3 0.1.41 → 0.1.44

package/lib/instructions/depositVault.js

@@ -16,15 +16,15 @@ 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");
+const token_instructions_1 = require("@project-serum/serum/lib/token-instructions");
 function depositVault(program, provider, payer, vaultPublicKey, depositAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         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 vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
-        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
-        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultAccount.vaultType);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultAccount.vaultType, true);
         const payerTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(payer.publicKey, vaultTypeAccountInfo.collateralMint);
         const vaultAssociatedCollateralAccountPublicKey = yield (0, Constants_1.findAssociatedTokenAddress)(vaultPublicKey, vaultTypeAccountInfo.collateralMint);
         const history = web3_js_1.Keypair.generate();
@@ -34,8 +34,8 @@ 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') {
+        const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, vaultPublicKey, depositAmount, 0, false, false);
+        if (vaultTypeAccountInfo.collateralMint.toString() === token_instructions_1.WRAPPED_SOL_MINT.toString()) {
             transaction.add(web3_js_1.SystemProgram.createAccount({
                 fromPubkey: payer.publicKey,
                 lamports: depositAmount + 2.04e6,
@@ -49,8 +49,8 @@ function depositVault(program, provider, payer, vaultPublicKey, depositAmount, o
             }));
             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, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, depositAmount, overrideTime));
-        if (vaultAccount.collateralType === 'SOL') {
+        transaction.add(yield depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultTypeAccountInfo.collateralMint.toString() === token_instructions_1.WRAPPED_SOL_MINT.toString() ? wrappedSolAccount.publicKey : payerTokenAccount, vaultPublicKey, vaultAssociatedCollateralAccountPublicKey, history.publicKey, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, vaultTypeAccountInfo.collateralMint, ushMintPublickey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, depositAmount, overrideTime));
+        if (vaultTypeAccountInfo.collateralMint.toString() === token_instructions_1.WRAPPED_SOL_MINT.toString()) {
             transaction.add(serum_1.TokenInstructions.closeAccount({
                 source: wrappedSolAccount.publicKey,
                 destination: payer.publicKey,

package/lib/instructions/liquidateVault.js

@@ -18,8 +18,7 @@ const Constants_1 = require("../Constants");
 function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
-        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultAccount.vaultType);
         const collateralMint = vaultTypeAccountInfo.collateralMint;
         const hedgeMintPublickey = yield (0, Constants_1.getHedgeMintPublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
@@ -30,24 +29,23 @@ function liquidateVault(program, provider, payer, vaultPublicKey, overrideTime)
         const feePoolAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, hedgeStakingPoolPublicKey, true);
         const vaultAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, vaultPublicKey, true);
         const poolAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, liquidationPoolStatePublicKey, true);
-        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, collateralMint, vaultAccount.vaultType, 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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, 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, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, 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.vaultType, overrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history, newEra]);
         return vaultPublicKey;
     });
 }
 exports.liquidateVault = liquidateVault;
-function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, poolState, poolEra, poolAssociatedTokenAccount, historyPublicKey, newEraPublicKey, feePool, feePoolAssociatedTokenAccount, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, collateralType, overrideTime) {
+function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, poolState, poolEra, poolAssociatedTokenAccount, historyPublicKey, newEraPublicKey, feePool, feePoolAssociatedTokenAccount, hedgeStakingPoolAssociatedUshTokenAccount, collateralMint, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, vaultTypeAccount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
         const liquidationPoolUshAccountPublickey = yield (0, Constants_1.getLiquidationPoolUshAccountPublicKey)();
-        const vaultTypeAccount = yield (0, Constants_1.getVaultTypeAccountPublicKey)(collateralType);
         return yield program.methods
             .liquidateVault(new anchor_1.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)) // override override time
         )

package/lib/instructions/loanVault.js

@@ -15,19 +15,20 @@ 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");
+const Errors_1 = require("../utils/Errors");
+const fs = require('fs');
 function loanVault(program, provider, payer, vaultPublicKey, loanAmount, overrideTime) {
     return __awaiter(this, void 0, void 0, function* () {
         const ushMintPublickey = yield (0, Constants_1.getUshMintPublicKey)();
         const payerUshAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, payer.publicKey);
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
-        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
-        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccount.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultAccount.vaultType);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccount.collateralMint, vaultAccount.vaultType, 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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, 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, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, loanAmount, overrideTime));
-        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history]);
+        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, loanAmount, overrideTime));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history]).catch(Errors_1.parseAnchorErrors);
         return vaultPublicKey;
     });
 }

package/lib/instructions/redeemVault.js

@@ -22,14 +22,13 @@ function redeemVault(program, provider, payer, vaultPublicKey, redeemAmount, tra
         // Prep the user to get USH back out at some point
         const payerUshAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, payer.publicKey);
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
-        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
-        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultAccount.vaultType);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultAccount.vaultType, 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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, 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, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, redeemAmount, transactionOverrideTime));
+        const transaction = new web3_js_1.Transaction().add(yield redeemVaultInstruction(program, payer.publicKey, payerUshAccount.address, payerTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount.address, history.publicKey, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount.address, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, redeemAmount, transactionOverrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history]);
         return vaultPublicKey;
     });

package/lib/instructions/refreshOraclePrice.js

@@ -32,7 +32,7 @@ function refreshOraclePriceInstruction(program, collateralType, network, overrid
             .accounts({
             oracleInfoAccount: oracleInfoAccount,
             vaultTypeAccount: vaultTypeAccount,
-            oracleChainlink: chainlinkAccunts[network],
+            oracleChainlink: chainlinkAccounts[network],
             oraclePyth: pythAccounts[network],
             oracleSwitchboard: switchboardAccounts[network],
             systemProgram: web3_js_1.SystemProgram.programId,
@@ -52,7 +52,7 @@ const pythAccounts = {
     Devnet: new web3_js_1.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
     MainnetBeta: new web3_js_1.PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG'),
 };
-const chainlinkAccunts = {
+const chainlinkAccounts = {
     Testing: web3_js_1.SystemProgram.programId,
     Devnet: new web3_js_1.PublicKey('FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'),
     MainnetBeta: web3_js_1.SystemProgram.programId, // CHAINLINK NOT ON MAINNET YET

package/lib/instructions/repayVault.js

@@ -21,13 +21,12 @@ function repayVault(program, provider, payer, vaultPublicKey, repayAmount, overr
         // Prep the user to get USH back out at some point
         const payerUshAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, ushMintPublickey, payer.publicKey);
         const vaultAccount = yield program.account.vault.fetch(vaultPublicKey);
-        const vaultTypeAccountPublicKey = yield (0, Constants_1.getVaultTypeAccountPublicKey)(vaultAccount.collateralType);
-        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
-        const vaultTypeAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultTypeAccountPublicKey, vaultTypeAccount.collateralMint);
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultAccount.vaultType);
+        const vaultTypeAssociatedTokenAccount = yield (0, Constants_1.findAssociatedTokenAddress)(vaultAccount.vaultType, 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 [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, 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, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, repayAmount, overrideTime));
+        const transaction = new web3_js_1.Transaction().add(yield repayVaultInstruction(program, payer.publicKey, payerUshAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, repayAmount, overrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history]);
         return vaultPublicKey;
     });

package/lib/instructions/updateVaultType.js

@@ -0,0 +1,47 @@
+"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.updateVaultTypeStatusInstruction = exports.updateVaultType = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const Constants_1 = require("../Constants");
+function updateVaultType(program, provider, payer, vaultTypeAccount, oracleInfoAccount, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultSystemStatePublicKey = yield (0, Constants_1.getVaultSystemStatePublicKey)();
+        const transaction = new web3_js_1.Transaction().add(yield updateVaultTypeStatusInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultTypeAccount, oracleInfoAccount, config));
+        yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer]);
+        return vaultSystemStatePublicKey;
+    });
+}
+exports.updateVaultType = updateVaultType;
+function updateVaultTypeStatusInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultTypeAccount, oracleInfoAccount, vaultTypeConfig) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    return __awaiter(this, void 0, void 0, function* () {
+        const config = {
+            maxDebtExtended: (_a = vaultTypeConfig.maxDebtExtended) !== null && _a !== void 0 ? _a : null,
+            minDebtPerVault: (_b = vaultTypeConfig.minDebtPerVault) !== null && _b !== void 0 ? _b : null,
+            loanInitFee: (_c = vaultTypeConfig.loanInitFee) !== null && _c !== void 0 ? _c : null,
+            oracleChainlink: (_d = vaultTypeConfig.oracleChainlink) !== null && _d !== void 0 ? _d : null,
+            oraclePyth: (_e = vaultTypeConfig.oraclePyth) !== null && _e !== void 0 ? _e : null,
+            oracleSwitchboard: (_f = vaultTypeConfig.oracleSwitchboard) !== null && _f !== void 0 ? _f : null,
+            deprecated: (_g = vaultTypeConfig.deprecated) !== null && _g !== void 0 ? _g : null,
+        };
+        return yield program.methods
+            .updateVaultType(config)
+            .accounts({
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            vaultType: vaultTypeAccount,
+            oracleInfoAccount: oracleInfoAccount,
+        })
+            .instruction();
+    });
+}
+exports.updateVaultTypeStatusInstruction = updateVaultTypeStatusInstruction;

package/lib/instructions/withdrawVault.js

@@ -24,15 +24,14 @@ 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 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(vaultTypeAccountPublicKey);
-        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultTypeAccountPublicKey, true);
+        const vaultTypeAccountInfo = yield program.account.vaultType.fetch(vaultAccount.vaultType);
+        const vaultTypeAssociatedTokenAccount = yield (0, spl_token_1.getOrCreateAssociatedTokenAccount)(provider.connection, payer, vaultTypeAccountInfo.collateralMint, vaultAccount.vaultType, 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 [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));
+        const [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey] = yield (0, getLinkedListAccounts_1.getLinkedListAccounts)(program, provider, vaultAccount.vaultType, 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, vaultAccount.vaultType, vaultTypeAssociatedTokenAccount.address, hedgeStakingPoolPublicKey, hedgeStakingPoolAssociatedUshTokenAccount, ushMintPublickey, history.publicKey, oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, withdrawAmount, overrideTime));
         yield (0, web3_js_1.sendAndConfirmTransaction)(provider.connection, transaction, [payer, history]);
         return vaultPublicKey;
     });

package/lib/state/VaultAccount.js

@@ -33,11 +33,11 @@ const borsh = __importStar(require("@project-serum/borsh"));
 class VaultAccount {
     constructor(vault, publicKey) {
         var _a, _b, _c;
-        /** Debt redistribution snapshop */
+        /** Debt redistribution snapshot */
         this.debtProductSnapshotBytes = new decimal_js_1.default(0);
-        /** Collateral redistribution snapshop' */
+        /** Collateral redistribution snapshot' */
         this.collateralAccumulatorSnapshotBytes = new decimal_js_1.default(0);
-        /** Current State of the vautl ("Open", "Closed", "Liquidated") */
+        /** Current State of the vault ("Open", "Closed", "Liquidated") */
         this.vaultStatus = '';
         this.publicKey = publicKey;
         this.vaultOwner = vault.vaultOwner;
@@ -51,11 +51,12 @@ class VaultAccount {
         if (vault.collateralAccumulatorSnapshotBytes) {
             this.collateralAccumulatorSnapshotBytes = (0, HedgeDecimal_1.DecimalFromU128)(vault.collateralAccumulatorSnapshotBytes.toString());
         }
-        this.collateralType = vault.collateralType;
+        this.vaultTypeName = vault.vaultTypeName;
         this.nextVaultToRedeem = vault.nextVaultToRedeem;
         if (vault.vaultStatus) {
             this.vaultStatus = Object.keys(vault.vaultStatus)[0];
         }
+        this.vaultType = vault.vaultType;
     }
     /**
      * Check if some `PublicKey` is the owner
@@ -110,9 +111,9 @@ class VaultAccount {
         this.denormalizedDebt = 0;
         this.vaultStatus = 'liquidated';
     }
-    updateDebtAndCollateral(vaultTypeAccuntData) {
-        const debtProductCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.debtRedistributionProduct);
-        const collateralAccumulatorCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.collateralRedistributionAccumulator);
+    updateDebtAndCollateral(vaultTypeAccountData) {
+        const debtProductCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccountData.debtRedistributionProduct);
+        const collateralAccumulatorCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccountData.collateralRedistributionAccumulator);
         this.denormalizedDebt = debtProductCurrent
             .div(this.debtProductSnapshotBytes)
             .mul(new decimal_js_1.default(this.denormalizedDebt))
@@ -135,7 +136,7 @@ class VaultAccount {
         if (this.nextVaultToRedeem) {
             nextVault = this.nextVaultToRedeem.toString().substring(0, 6);
         }
-        return `Vault(${this.vaultNumber}): ${this.publicKey.toString().substring(0, 6)}. Debt: ${this.denormalizedDebt} Collat: ${this.deposited} Ratio: ${collateralRatio} NextVault: ${nextVault} ${arrow} `;
+        return `Vault(${this.vaultNumber}): ${this.publicKey.toString().substring(0, 6)}. Debt: ${this.denormalizedDebt} Collat: ${this.deposited} Ratio: ${collateralRatio} ${arrow} `;
     }
     /**
      * Creates a VaultAccount from a slice of data

package/lib/state/VaultType.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const decimal_js_1 = __importDefault(require("decimal.js"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+class VaultType {
+    constructor(config, publicKey) {
+        var _a;
+        this.publicKey = publicKey;
+        this.name = config.collateralType;
+        this.loanInitFee = (0, HedgeDecimal_1.DecimalFromU128)(config.loanInitFee);
+        this.minCollateralRatio = (0, HedgeDecimal_1.DecimalFromU128)(config.minCollateralRatio);
+        this.interestRatePerSecond = (0, HedgeDecimal_1.DecimalFromU128)(config.interestRatePerSecond);
+        this.minDebtPerVault = (0, HedgeDecimal_1.DecimalFromU128)(config.minDebtPerVault);
+        this.maxDebtExtended = (0, HedgeDecimal_1.DecimalFromU128)(config.maxDebtExtended);
+        this.canBeRedeemed = config.canBeRedeemed;
+        this.collateralMint = config.collateralMint;
+        this.firstVaultToRedeem = config.firstVaultToRedeem;
+        this.recentPrice = (0, HedgeDecimal_1.DecimalFromU128)((_a = config.recentPrice) === null || _a === void 0 ? void 0 : _a.toString());
+        this.priceLastUpdatedTimestamp = new decimal_js_1.default(config.priceLastUpdatedTimestamp.toString());
+        this.collateralHeld = new decimal_js_1.default(config.collateralHeld.toString());
+        this.denormalizedDebtExtended = new decimal_js_1.default(config.denormalizedDebtExtended.toString());
+        this.debtRedistributionProduct = (0, HedgeDecimal_1.DecimalFromU128)(config.debtRedistributionProduct.toString());
+        this.collateralRedistributionAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(config.collateralRedistributionAccumulator.toString());
+        this.cumulativeRate = (0, HedgeDecimal_1.DecimalFromU128)(config.cumulativeRate.toString());
+        this.cumulativeRateLastUpdated = new decimal_js_1.default(config.cumulativeRateLastUpdated.toString());
+        this.collateralIndex = config.collateralIndex.toNumber();
+    }
+}
+exports.default = VaultType;

package/lib/utils/Errors.js

@@ -5,6 +5,7 @@ const anchor_1 = require("@project-serum/anchor");
 const vault_1 = require("../idl/vault");
 function parseAnchorErrors(error) {
     const idlErrors = (0, anchor_1.parseIdlErrors)(vault_1.IDL);
+    console.log(error);
     const parsedError = anchor_1.ProgramError.parse(error, idlErrors);
     if (parsedError !== null) {
         throw parsedError;

package/lib/utils/Sender.js

@@ -0,0 +1,32 @@
+"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.sendAndConfirmWithDebug = void 0;
+function sendAndConfirmWithDebug(connection, transaction, signers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return connection
+            .sendTransaction(transaction, signers)
+            .then((signature) => {
+            return connection
+                .confirmTransaction(signature)
+                .then((signatureContext) => {
+                return signature;
+            })
+                .catch((error) => {
+                console.log('There was an error confirming the transaction', error);
+            });
+        })
+            .catch((error) => {
+            console.log('There was an error sending the transaction', error);
+        });
+    });
+}
+exports.sendAndConfirmWithDebug = sendAndConfirmWithDebug;

package/lib/utils/getLinkedListAccounts.js

@@ -21,13 +21,14 @@ const decimal_js_1 = __importDefault(require("decimal.js"));
 const bs58_1 = __importDefault(require("bs58"));
 function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, depositAmount, loanAmount, redeem, liquidate, cachedVaults) {
     return __awaiter(this, void 0, void 0, function* () {
-        console.log('Getting getLinkedListAccounts');
+        // console.log('Getting getLinkedListAccounts')
         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 accountInfo = yield program.provider.connection.getAccountInfo(vaultPublicKey);
         const thisVault = new VaultAccount_1.VaultAccount(thisVaultData, vaultPublicKey);
         // Load all the vaults
         let vaults;
@@ -50,10 +51,10 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
             // vaults = allVaults.map((vault) => {
             //   return new VaultAccount(vault.account, vault.publicKey)
             // })
-            vaults = yield getMiniVaults(program, vaultTypeAccount.collateralType);
+            vaults = yield getMiniVaults(program, vaultTypeAccount.vaultTypeName);
         }
-        console.log('Vault count found:', vaults.length);
-        console.log('First Vault', vaults[0]);
+        // console.log('Vault count found:', vaults.length)
+        // console.log('First Vault', vaults[0])
         // Filter out the accounts that are not open
         // TODO filter on vault status. Or we enable people to "close out" empty vaults 
         // vaults = _.filter(vaults, (vault) => {
@@ -76,6 +77,11 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
         if (indexBefore > 0) {
             oldSmallerPublicKey = vaults[indexBefore - 1].publicKey;
         }
+        // Pretty print the list again
+        // console.log('Sorted open vaults. Index Before: ', indexBefore)
+        // console.log(vaults.map((vault) => {
+        //   return vault.toString(vaultPublicKey)
+        // }))
         // Pretty print all the vaults before the operation
         // console.log('Sorted open vaults BEFORE at index:', indexBefore)
         // let correctOrderBefore = true
@@ -89,7 +95,7 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
         //   }
         // }
         // if (correctOrderBefore) {
-        //   console.log(`Verfied the on-chain order of vault type:`, vaultTypeAccount.collateralType)
+        //   console.log(`Verified the on-chain order of vault type:`, vaultTypeAccount.collateralType)
         // } else {
         //   throw new Error('On-Chian vaults not in order!')
         // }
@@ -104,7 +110,7 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
             vaults[indexBefore] = thisVault;
         }
         // 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
+        // this vault with the operation we're going to apply
         const newNormalizedDebt = new decimal_js_1.default(loanAmount);
         const vaultTypeCompoundedInterest = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccount.cumulativeRate.toString());
         vaults[indexBefore].updateDebtAndCollateral(vaultTypeAccount);
@@ -121,11 +127,6 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
         }
         // 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 at index: ', indexAfter)
-        // console.log(vaults.map((vault) => {
-        //   return vault.toString(vaultPublicKey)
-        // }))
         // Search for the vaults new position
         let indexAfter = -1;
         vaults.forEach((vault, index) => {
@@ -141,8 +142,7 @@ function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vau
         //   })
         // )
         // Print where it moved from / to
-        console.log('Index Before', indexBefore);
-        console.log('Index After', indexAfter);
+        // console.log('Index After', indexAfter)
         // Save references to the new left and right
         if (indexAfter > 0) {
             newSmallerPublicKey = vaults[indexAfter - 1].publicKey;
@@ -168,7 +168,7 @@ function sortVaults(a, b) {
     }
     return aRatio - bRatio;
 }
-function getMiniVaults(program, collateralType) {
+function getMiniVaults(program, vaultTypeName) {
     return __awaiter(this, void 0, void 0, function* () {
         const filters = [
             // Filter for Vault Accounts
@@ -179,7 +179,7 @@ function getMiniVaults(program, collateralType) {
             // Filter for Vaults with this collateral type
             {
                 memcmp: {
-                    bytes: bs58_1.default.encode(VaultAccount_1.VaultAccount.getBufferForString(collateralType)),
+                    bytes: bs58_1.default.encode(VaultAccount_1.VaultAccount.getBufferForString(vaultTypeName)),
                     offset: 8 + 32 + 24,
                 },
             },

package/lib/utils/sendAndConfirmWithDebug.js

@@ -0,0 +1,35 @@
+"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 });
+function sendAndConfirmWithDebug(connection, transaction, signers) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return connection
+            .sendTransaction(transaction, signers)
+            .then((signature) => {
+            return connection
+                .confirmTransaction(signature)
+                .then((signatureContext) => {
+                return signature;
+            })
+                .catch((error) => {
+                console.log('There was an error confirming the transaction', error);
+                console.trace();
+                throw error;
+            });
+        })
+            .catch((error) => {
+            console.log('There was an error sending the transaction', error);
+            console.trace();
+            throw error;
+        });
+    });
+}
+exports.default = sendAndConfirmWithDebug;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedge-web3",
-  "version": "0.1.41",
+  "version": "0.1.44",
   "description": "Hedge Javascript Web3 API",
   "main": "lib/index.js",
   "types": "declarations/index.d.ts",
@@ -14,7 +14,7 @@
   "author": "Chris Coudron <coudron@hedge.so>",
   "license": "ISC",
   "dependencies": {
-    "@project-serum/anchor": "^0.24.2",
+    "@project-serum/anchor": "0.24.2",
     "@project-serum/serum": "^0.13.61",
     "@rollup/plugin-typescript": "^8.3.0",
     "@solana/buffer-layout": "^4.0.0",

package/src/Constants.ts

@@ -4,7 +4,7 @@ import {
 } from '@solana/spl-token'
 import { PublicKey } from '@solana/web3.js'
 
-export const HEDGE_PROGRAM_ID = 'HDG4FDos8fyrB79qMCe98gaFjNEy5kpxGNjMc5V8M6TJ'
+export const HEDGE_PROGRAM_ID = 'zooJaircVAoQ4e7EXRDocnsbB7UPYQ6J7bKyZEMh784'
 export const HEDGE_PROGRAM_PUBLICKEY = new PublicKey(HEDGE_PROGRAM_ID)
 
 export const CHAINLINK_SOL_USD_ID =