hedge-web3 0.1.10 → 0.1.14

package/lib/index.js

@@ -5,6 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var anchor = require('@project-serum/anchor');
 var splToken = require('@solana/spl-token');
 var web3_js = require('@solana/web3.js');
+var serum = require('@project-serum/serum');
+var uuid = require('uuid');
 var Decimal = require('decimal.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
@@ -79,12 +81,12 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
                 {
-                    name: 'splAssociatedTokenProgramInfo',
+                    name: 'associatedTokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -149,12 +151,12 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
                 {
-                    name: 'splAssociatedTokenProgramInfo',
+                    name: 'associatedTokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -212,7 +214,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -297,7 +299,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -484,7 +486,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -539,7 +541,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -605,7 +607,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -664,7 +666,7 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -744,7 +746,7 @@ const vaultIdl = {
                     isSigner: true
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -810,12 +812,12 @@ const vaultIdl = {
                     isSigner: false
                 },
                 {
-                    name: 'splTokenProgramInfo',
+                    name: 'tokenProgram',
                     isMut: false,
                     isSigner: false
                 },
                 {
-                    name: 'splAssociatedTokenProgramInfo',
+                    name: 'associatedTokenProgram',
                     isMut: false,
                     isSigner: false
                 },
@@ -1493,39 +1495,43 @@ function parseAnchorErrors(error) {
     throw error;
 }
 
-const HEDGE_PROGRAM_ID = 'hhhJmQPMmb2sNoTQK1ip7ZRGpRdGfskEEgjacf9XFWv';
+const HEDGE_PROGRAM_ID = 'kkkBajjjT3rKjB3uGzSN83aLoQmaRwfXxbbBj8VLbtH';
 const HEDGE_PROGRAM_PUBLICKEY = new web3_js.PublicKey(HEDGE_PROGRAM_ID);
 const CHAINLINK_SOL_USD_ID = 'FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf';
 const CHAINLINK_SOL_USD_PUBLICKEY = new web3_js.PublicKey(CHAINLINK_SOL_USD_ID);
 const enc = new TextEncoder();
 async function getLiquidationPoolStatePublicKey() {
-    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [poolPublicKey, bump];
+    const [poolPublicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return poolPublicKey;
 }
 async function getLiquidationPoolUsdhAccountPublicKey() {
-    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [poolPublicKey, bump];
+    const [poolPublicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return poolPublicKey;
 }
 async function getUsdhMintPublicKey() {
-    const [findMintPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [findMintPublicKey, bump];
+    const [findMintPublicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return findMintPublicKey;
 }
 async function getVaultSystemStatePublicKey() {
-    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [publicKey, bump];
+    const [publicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return publicKey;
 }
 async function getHedgeMintPublicKey() {
-    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return [publicKey, bump];
+    const [publicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return publicKey;
 }
 async function getPoolPublicKeyForMint(mintPublicKey) {
     const strToEncode = (mintPublicKey.toString().substring(0, 12));
     const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode(strToEncode)], HEDGE_PROGRAM_PUBLICKEY);
     return [publicKey, bump, strToEncode];
 }
-async function getSolCollateralPriceAccountPublicKey() {
-    const [collateralPriceAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('Price')], HEDGE_PROGRAM_PUBLICKEY);
-    return collateralPriceAccount;
+async function getCollateralStateAccountPublicKey(collateralType) {
+    const [collateralStateAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY);
+    return collateralStateAccount;
+}
+async function findVaultAddress(vaultSalt) {
+    const [vaultAddress] = await web3_js.PublicKey.findProgramAddress([enc.encode('Vault'), enc.encode(vaultSalt)], HEDGE_PROGRAM_PUBLICKEY);
+    return vaultAddress;
 }
 async function findAssociatedTokenAddress(walletAddress, tokenMintAddress) {
     return (await web3_js.PublicKey.findProgramAddress([
@@ -1542,8 +1548,8 @@ async function createStakingPool(program, provider, payer, mintPublicKey, hedgeT
     return poolPublickey;
 }
 async function createStakingPoolInstruction(program, payerPublicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const [poolPublickey, poolBump, poolSeedPhrase] = await getPoolPublicKeyForMint(mintPublicKey);
     const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, mintPublicKey);
     const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey);
@@ -1557,8 +1563,8 @@ async function createStakingPoolInstruction(program, payerPublicKey, mintPublicK
             poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
             poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
             rent: web3_js.SYSVAR_RENT_PUBKEY,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
-            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
@@ -1585,8 +1591,8 @@ async function depositStakingPoolInstruction(program, payerPublicKey, poolPositi
             poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
             payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
             rent: web3_js.SYSVAR_RENT_PUBKEY,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
-            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
@@ -1600,15 +1606,16 @@ async function withdrawStakingPool(program, provider, payer, poolPositionPublicK
     return poolPosition.publicKey;
 }
 async function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const hedgeMintPublickey = await getHedgeMintPublicKey();
     const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey);
     const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey);
     const poolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(poolPublickey, usdhMintPublickey);
     const payerAssociatedStakedTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey);
     const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payerPublicKey, hedgeMintPublickey);
     const payerAssociatedUsdhAccount = await findAssociatedTokenAddress(payerPublicKey, usdhMintPublickey);
+    const communityHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMintPublickey);
     return program.instruction.withdrawStakingPool(new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
     {
         accounts: {
@@ -1621,88 +1628,274 @@ async function withdrawStakingPoolInstruction(program, payerPublicKey, poolPosit
             payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
             payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
             payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
+            communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
             hedgeMint: hedgeMintPublickey,
             stakedTokenMint: stakedTokenMintPublicKey,
             usdhMint: usdhMintPublickey,
             rent: web3_js.SYSVAR_RENT_PUBKEY,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
-            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
     });
 }
 
-async function createVault(program, provider, payer, depositAmount, collateralRatio) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+async function depositLiquidationPool(program, provider, payer, depositAmount, overrideStartTime) {
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const poolPosition = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await depositLiquidationPoolInstruction(program, payer.publicKey, payerUsdhAccount.address, poolPosition.publicKey, depositAmount, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors);
+    return poolPosition.publicKey;
+}
+async function depositLiquidationPoolInstruction(program, payerPublicKey, payerUsdhAccount, poolPositionPublicKey, depositAmount, overrideStartTime) {
+    const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey();
+    const liquidationPoolState = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+    const poolUSDHAccount = await getLiquidationPoolUsdhAccountPublicKey();
+    const usdhMint = await getUsdhMintPublicKey();
+    return program.instruction.depositLiquidationPool(new anchor.BN(depositAmount), new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            poolState: liquidationPoolStatePublicKey,
+            poolEra: liquidationPoolState.currentEra,
+            poolPosition: poolPositionPublicKey,
+            poolUsdhAccount: poolUSDHAccount,
+            usdhMint: usdhMint,
+            payer: payerPublicKey,
+            ownerUsdhAccount: payerUsdhAccount,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            rent: web3_js.SYSVAR_RENT_PUBKEY
+        },
+        signers: []
+    });
+}
+
+async function closeLiquidationPoolPosition(program, provider, poolPosition, payer, overrideStartTime) {
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const poolState = await getLiquidationPoolStatePublicKey();
+    const liquidationPositionAccount = await program.account.liquidationPosition.fetch(poolPosition);
+    const poolEra = liquidationPositionAccount.era;
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const poolUsdhAccount = await getLiquidationPoolUsdhAccountPublicKey();
+    const hedgeMint = await getHedgeMintPublicKey();
+    const payerAssociatedHedgeAccount = await findAssociatedTokenAddress(payer.publicKey, hedgeMint);
+    const communityAssociatedHedgeTokenAccount = await findAssociatedTokenAddress(vaultSystemStatePublicKey, hedgeMint);
+    const transaction = new web3_js.Transaction().add(await closeLiquidationPoolPositionInstruction(program, vaultSystemStatePublicKey, poolState, poolEra, poolPosition, poolUsdhAccount, payer.publicKey, payerUsdhAccount.address, hedgeMint, payerAssociatedHedgeAccount, communityAssociatedHedgeTokenAccount, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
+    return poolPosition;
+}
+async function closeLiquidationPoolPositionInstruction(program, vaultSystemState, poolState, poolEra, poolPosition, poolUsdhAccount, payerPublicKey, payerUsdhAccount, hedgeMint, payerAssociatedHedgeAccount, communityAssociatedHedgeTokenAccount, overrideStartTime) {
+    return program.instruction.closeLiquidationPoolPosition(new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            vaultSystemState: vaultSystemState,
+            poolState: poolState,
+            poolEra: poolEra,
+            poolPosition: poolPosition,
+            poolUsdhAccount: poolUsdhAccount,
+            payer: payerPublicKey,
+            ownerUsdhAccount: payerUsdhAccount,
+            hedgeMint: hedgeMint,
+            payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+            communityAssociatedHedgeTokenAccount: communityAssociatedHedgeTokenAccount,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            rent: web3_js.SYSVAR_RENT_PUBKEY
+        },
+        signers: []
+    });
+}
+
+async function claimLiquidationPoolPosition(program, provider, poolPosition, payer, collateralType, overrideStartTime) {
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralMint = collateralStateAccountInfo.collateralMint;
+    const poolStatePublicKey = await getLiquidationPoolStatePublicKey();
+    const poolAssociatedTokenAccount = await findAssociatedTokenAddress(poolStatePublicKey, collateralMint);
+    const payerAssociatedTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralMint);
+    const transaction = new web3_js.Transaction().add(await claimLiquidationPoolPositionInstruction(program, poolStatePublicKey, poolAssociatedTokenAccount, collateralStateAccountPublicKey, collateralMint, poolPosition, payer.publicKey, payerAssociatedTokenAccount));
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
+    return payerAssociatedTokenAccount;
+}
+async function claimLiquidationPoolPositionInstruction(program, poolState, poolAssociatedTokenAccount, collateralStateAccount, collateralMint, poolPosition, payer, payerAssociatedTokenAccount, overrideStartTime) {
+    return program.instruction.claimLiquidationPoolPosition({
+        accounts: {
+            poolState: poolState,
+            poolAssociatedTokenAccount: poolAssociatedTokenAccount,
+            collateralStateAccount: collateralStateAccount,
+            collateralMint: collateralMint,
+            poolPosition: poolPosition,
+            payer: payer,
+            payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            rent: web3_js.SYSVAR_RENT_PUBKEY
+        },
+        signers: []
+    });
+}
+
+async function createVault(program, provider, payer, collateralType, depositAmount, collateralRatio) {
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    const salt = uuid.v4().substring(0, 8);
+    const newVaultPublicKey = await findVaultAddress(salt);
+    const history = web3_js.Keypair.generate();
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
-    const newVault = web3_js.Keypair.generate();
-    const history = web3_js.Keypair.generate();
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(createVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, newVault.publicKey, history.publicKey, depositAmount, collateralRatio));
-    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, newVault, history], provider === null || provider === void 0 ? void 0 : provider.opts);
-    return newVault.publicKey;
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(collateralType);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint);
+    const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(newVaultPublicKey, collateralStateAccountInfo.collateralMint);
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const wrappedSolAccount = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction();
+    const signers = [payer, history];
+    if (collateralType === 'SOL') {
+        transaction.add(web3_js.SystemProgram.createAccount({
+            fromPubkey: payer.publicKey,
+            lamports: depositAmount + 2.04e6,
+            newAccountPubkey: wrappedSolAccount.publicKey,
+            programId: splToken.TOKEN_PROGRAM_ID,
+            space: 165
+        }), serum.TokenInstructions.initializeAccount({
+            account: wrappedSolAccount.publicKey,
+            mint: serum.TokenInstructions.WRAPPED_SOL_MINT,
+            owner: payer.publicKey
+        }));
+        signers.push(wrappedSolAccount);
+    }
+    transaction.add(await createVaultInstruction(program, salt, vaultSystemStatePublicKey, payer.publicKey, collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount, newVaultPublicKey, vaultAssociatedCollateralAccountPublicKey, collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint, history.publicKey, depositAmount, collateralRatio));
+    if (collateralType === 'SOL') {
+        transaction.add(serum.TokenInstructions.closeAccount({
+            source: wrappedSolAccount.publicKey,
+            destination: payer.publicKey,
+            owner: payer.publicKey
+        }));
+    }
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, signers, provider === null || provider === void 0 ? void 0 : provider.opts).catch(parseAnchorErrors);
+    return newVaultPublicKey;
 }
-function createVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount, collateralRatio) {
-    const ix = program.instruction.createVault(new anchor.BN(depositAmount), new anchor.BN(collateralRatio), {
+async function createVaultInstruction(program, salt, vaultSystemStatePublicKey, payerPublicKey, payerTokenAccountPublicKey, vaultPublicKey, vaultAssociatedCollateralPublicKey, collateralStateAccount, collateralMint, historyPublicKey, depositAmount, collateralRatio) {
+    const ix = program.instruction.createVault(salt, new anchor.BN(depositAmount), new anchor.BN(collateralRatio), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
+            collateralStateAccount: collateralStateAccount,
             vault: vaultPublicKey,
+            vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
             history: historyPublicKey,
             payer: payerPublicKey,
-            systemProgram: web3_js.SystemProgram.programId
+            payerTokenAccount: payerTokenAccountPublicKey,
+            collateralMint: collateralMint,
+            systemProgram: web3_js.SystemProgram.programId,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            rent: web3_js.SYSVAR_RENT_PUBKEY
         },
         signers: []
     });
     return ix;
 }
 
-async function depositVault(program, provider, payer, vaultPublicKey, depositAmount) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+async function depositVault(program, provider, payer, vaultPublicKey, 
+// collateralType: string,
+depositAmount) {
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint);
+    const payerTokenAccount = await findAssociatedTokenAddress(payer.publicKey, collateralStateAccountInfo.collateralMint);
+    const vaultAssociatedCollateralAccountPublicKey = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint);
     const history = web3_js.Keypair.generate();
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, depositAmount));
-    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const wrappedSolAccount = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction();
+    const signers = [payer, history];
+    if (vaultAccount.collateralType === 'SOL') {
+        transaction.add(web3_js.SystemProgram.createAccount({
+            fromPubkey: payer.publicKey,
+            lamports: depositAmount + 2.04e6,
+            newAccountPubkey: wrappedSolAccount.publicKey,
+            programId: splToken.TOKEN_PROGRAM_ID,
+            space: 165
+        }), serum.TokenInstructions.initializeAccount({
+            account: wrappedSolAccount.publicKey,
+            mint: serum.TokenInstructions.WRAPPED_SOL_MINT,
+            owner: payer.publicKey
+        }));
+        signers.push(wrappedSolAccount);
+    }
+    transaction.add(await depositVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultAccount.collateralType === 'SOL' ? wrappedSolAccount.publicKey : payerTokenAccount, vaultPublicKey, vaultAssociatedCollateralAccountPublicKey, history.publicKey, collateralStateAccountPublicKey, collateralAssociatedTokenAccount, collateralStateAccountInfo.collateralMint, depositAmount));
+    if (vaultAccount.collateralType === 'SOL') {
+        transaction.add(serum.TokenInstructions.closeAccount({
+            source: wrappedSolAccount.publicKey,
+            destination: payer.publicKey,
+            owner: payer.publicKey
+        }));
+    }
+    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, signers, provider.opts);
     return vaultPublicKey;
 }
-function depositVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount) {
+async function depositVaultInstruction(program, vaultSystemStatePublicKey, vaultOwner, vaultOwnerTokenAccount, vaultPublicKey, vaultAssociatedTokenAccount, historyPublicKey, collateralStateAccountPublicKey, collateralAssociatedTokenAccount, collateralMint, depositAmount) {
     return program.instruction.depositVault(new anchor.BN(depositAmount), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
-            vaultAccount: vaultPublicKey,
+            collateralStateAccount: collateralStateAccountPublicKey,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+            collateralTokenMint: collateralMint,
+            vault: vaultPublicKey,
+            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
             history: historyPublicKey,
-            vaultOwner: payerPublicKey,
-            systemProgram: web3_js.SystemProgram.programId
+            vaultOwner: vaultOwner,
+            vaultOwnerTokenAccount: vaultOwnerTokenAccount,
+            systemProgram: web3_js.SystemProgram.programId,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID
         },
         signers: []
     });
 }
 
 async function withdrawVault(program, provider, payer, vaultPublicKey, withdrawAmount) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const transaction = new web3_js.Transaction().add(await withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, withdrawAmount));
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccount = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const vaultAssociatedCollateralAccount = await findAssociatedTokenAddress(vaultPublicKey, serum.TokenInstructions.WRAPPED_SOL_MINT);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccount);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccount, collateralStateAccountInfo.collateralMint);
+    const token = new splToken.Token(provider.connection, collateralStateAccountInfo.collateralMint, splToken.TOKEN_PROGRAM_ID, payer);
+    const destinationTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const transaction = new web3_js.Transaction().add(await withdrawVaultInstruction(program, vaultSystemStatePublicKey, payer.publicKey, destinationTokenAccount.address, vaultPublicKey, vaultAssociatedCollateralAccount, collateralStateAccount, collateralAssociatedTokenAccount, history.publicKey, withdrawAmount));
     await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, vaultPublickey, historyPublicKey, withdrawAmount) {
-    const solPriceAccount = await getSolCollateralPriceAccountPublicKey();
+async function withdrawVaultInstruction(program, vaultSystemStatePublicKey, payerPublicKey, destinationTokenAccount, vaultPublickey, vaultAssociatedCollateralPublicKey, collateralStateAccount, collateralAssociatedTokenAccount, historyPublicKey, withdrawAmount) {
     return program.instruction.withdrawVault(new anchor.BN(withdrawAmount), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
-            vaultAccount: vaultPublickey,
+            collateralStateAccount: collateralStateAccount,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+            vault: vaultPublickey,
+            vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
             history: historyPublicKey,
             vaultOwner: payerPublicKey,
-            priceForCollateral: solPriceAccount,
+            destinationTokenAccount: destinationTokenAccount,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
@@ -1710,34 +1903,40 @@ async function withdrawVaultInstruction(program, vaultSystemStatePublicKey, paye
 }
 
 async function loanVault(program, provider, payer, vaultPublicKey, loanAmount) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const collateralStateAccount = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccount.collateralMint);
+    const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccount.collateralMint);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await loanVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, loanAmount));
+    const transaction = new web3_js.Transaction().add(await loanVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, collateralStateAccountPublicKey, collateralAssociatedTokenAccount, loanAmount));
     await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function loanVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, loanAmount) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
+async function loanVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, collateralStateAccount, collateralAssociatedTokenAccount, loanAmount) {
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const hedgeMintPublickey = await getHedgeMintPublicKey();
     const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
     const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, usdhMintPublickey);
-    const solPriceAccount = await getSolCollateralPriceAccountPublicKey();
     return program.instruction.loanVault(new anchor.BN(loanAmount), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
+            collateralStateAccount: collateralStateAccount,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
             vaultAccount: vaultPublickey,
+            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
             history: historyPublicKey,
             feePool: hedgeStakingPoolPublicKey,
             feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
             usdhMint: usdhMintPublickey,
             vaultOwner: payerPublicKey,
             ownerUsdhAccount: ownerUsdhAccount,
-            priceForCollateral: solPriceAccount,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
@@ -1745,132 +1944,194 @@ async function loanVaultInstruction(program, payerPublicKey, ownerUsdhAccount, v
 }
 
 async function repayVault(program, provider, payer, vaultPublicKey, repayAmount) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const collateralStateAccount = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccount.collateralMint);
+    const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccount.collateralMint);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await repayVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount));
+    const transaction = new web3_js.Transaction().add(await repayVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, collateralStateAccountPublicKey, collateralAssociatedTokenAccount, repayAmount));
     await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function repayVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
+async function repayVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, collateralStateAccount, collateralAssociatedTokenAccount, repayAmount) {
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const hedgeMintPublickey = await getHedgeMintPublicKey();
     const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
     const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, usdhMintPublickey);
     return program.instruction.repayVault(new anchor.BN(repayAmount), {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
+            collateralStateAccount: collateralStateAccount,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
             vaultAccount: vaultPublickey,
+            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
             history: historyPublicKey,
             feePool: hedgeStakingPoolPublicKey,
             feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
             usdhMint: usdhMintPublickey,
             vaultOwner: payerPublicKey,
             ownerUsdhAccount: ownerUsdhAccount,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
     });
 }
 
-async function redeemVault(program, provider, payer, vaultPublicKey, repayAmount, transactionOverrideTime) {
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+async function redeemVault(program, provider, payer, vaultPublicKey, redeemAmount, transactionOverrideTime) {
+    const usdhMintPublickey = await getUsdhMintPublicKey();
     const USDH = new splToken.Token(provider.connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
     // Prep the user to get USDH back out at some point
     const payerUsdhAccount = await USDH.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralStateAccountInfo.collateralMint);
+    const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralStateAccountInfo.collateralMint);
+    const token = new splToken.Token(provider.connection, collateralStateAccountInfo.collateralMint, splToken.TOKEN_PROGRAM_ID, payer);
+    const payerTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey);
     const history = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await redeemVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount, transactionOverrideTime));
+    const transaction = new web3_js.Transaction().add(await redeemVaultInstruction(program, payer.publicKey, payerUsdhAccount.address, payerTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, history.publicKey, collateralStateAccountPublicKey, collateralAssociatedTokenAccount, redeemAmount, transactionOverrideTime));
     await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history], provider.opts);
     return vaultPublicKey;
 }
-async function redeemVaultInstruction(program, payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount, transactionOverrideTime) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
+async function redeemVaultInstruction(program, payerPublicKey, payerUsdhAccount, destinationTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, historyPublicKey, collateralStateAccount, collateralAssociatedTokenAccount, redeemAmount, transactionOverrideTime) {
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const hedgeMintPublickey = await getHedgeMintPublicKey();
     const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
     const hedgeStakingPoolAssociatedUsdhTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, usdhMintPublickey);
-    const solPriceAccount = await getSolCollateralPriceAccountPublicKey();
-    return program.instruction.redeemVault(new anchor.BN(repayAmount), new anchor.BN(transactionOverrideTime !== null && transactionOverrideTime !== void 0 ? transactionOverrideTime : (Date.now() / 1000)), // override start time
+    return program.instruction.redeemVault(new anchor.BN(redeemAmount), new anchor.BN(transactionOverrideTime !== null && transactionOverrideTime !== void 0 ? transactionOverrideTime : (Date.now() / 1000)), // override start time
     {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
-            vaultAccount: vaultPublickey,
+            collateralStateAccount: collateralStateAccount,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+            vault: vaultPublickey,
+            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
             history: historyPublicKey,
             feePool: hedgeStakingPoolPublicKey,
             feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
             usdhMint: usdhMintPublickey,
             payer: payerPublicKey,
-            payerUsdhAccount: ownerUsdhAccount,
-            priceForCollateral: solPriceAccount,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            payerUsdhAccount: payerUsdhAccount,
+            destinationTokenAccount: destinationTokenAccount,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
     });
 }
 
-async function liquidateVault(program, provider, payer, vaultPublicKey) {
+async function liquidateVault(program, provider, payer, vaultPublicKey, preload) {
+    const vaultAccount = await program.account.vault.fetch(vaultPublicKey);
+    const collateralStateAccountPublicKey = await getCollateralStateAccountPublicKey(vaultAccount.collateralType);
+    const collateralStateAccountInfo = await program.account.collateralState.fetch(collateralStateAccountPublicKey);
+    const collateralMint = collateralStateAccountInfo.collateralMint;
+    const token = new splToken.Token(provider.connection, collateralMint, splToken.TOKEN_PROGRAM_ID, payer);
+    const hedgeMintPublickey = await getHedgeMintPublicKey();
+    const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
+    const liquidationPoolStatePublicKey = await getLiquidationPoolStatePublicKey();
+    const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+    const payerAssociatedTokenAccount = await token.getOrCreateAssociatedAccountInfo(payer.publicKey);
+    const feePoolAssociatedTokenAccount = await findAssociatedTokenAddress(hedgeStakingPoolPublicKey, collateralMint);
+    const vaultAssociatedTokenAccount = await findAssociatedTokenAddress(vaultPublicKey, collateralMint);
+    const poolAssociatedTokenAccount = await findAssociatedTokenAddress(liquidationPoolStatePublicKey, collateralMint);
+    const collateralAssociatedTokenAccount = await findAssociatedTokenAddress(collateralStateAccountPublicKey, collateralMint);
     const history = web3_js.Keypair.generate();
     const newEra = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await liquidateVaultInstruction(program, payer.publicKey, vaultPublicKey, history.publicKey, newEra.publicKey));
+    const transaction = new web3_js.Transaction();
+    transaction.add(await liquidateVaultInstruction(program, payer.publicKey, payerAssociatedTokenAccount.address, vaultPublicKey, vaultAssociatedTokenAccount, liquidationPoolStatePublicKey, poolStateInfo.currentEra, poolAssociatedTokenAccount, history.publicKey, newEra.publicKey, hedgeStakingPoolPublicKey, feePoolAssociatedTokenAccount, collateralMint, collateralAssociatedTokenAccount, vaultAccount.collateralType, preload));
     await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, history, newEra], provider.opts);
     return vaultPublicKey;
 }
-async function liquidateVaultInstruction(program, payerPublicKey, vaultPublickey, historyPublicKey, newEraPublicKey) {
-    const [vaultSystemStatePublicKey] = await getVaultSystemStatePublicKey();
-    const [usdhMintPublickey] = await getUsdhMintPublicKey();
-    const [hedgeMintPublickey] = await getHedgeMintPublicKey();
-    const [hedgeStakingPoolPublicKey] = await getPoolPublicKeyForMint(hedgeMintPublickey);
-    const [liquidationPoolStatePublicKey] = await getLiquidationPoolStatePublicKey();
-    const [liquidationPoolUsdhAccountPublickey] = await getLiquidationPoolUsdhAccountPublicKey();
-    const solPriceAccount = await getSolCollateralPriceAccountPublicKey();
-    const poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
-    return program.instruction.liquidateVault({
+async function liquidateVaultInstruction(program, payerPublicKey, payerAssociatedTokenAccount, vaultPublickey, vaultAssociatedTokenAccount, poolState, poolEra, poolAssociatedTokenAccount, historyPublicKey, newEraPublicKey, feePool, feePoolAssociatedTokenAccount, collateralMint, collateralAssociatedTokenAccount, collateralType, preload) {
+    const vaultSystemStatePublicKey = await getVaultSystemStatePublicKey();
+    const usdhMintPublickey = await getUsdhMintPublicKey();
+    const liquidationPoolUsdhAccountPublickey = await getLiquidationPoolUsdhAccountPublicKey();
+    const collateralStateAccount = await getCollateralStateAccountPublicKey(collateralType);
+    const payload = {
         accounts: {
             vaultSystemState: vaultSystemStatePublicKey,
-            poolEra: poolStateInfo.currentEra,
+            collateralStateAccount: collateralStateAccount,
+            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
+            collateralMint: collateralMint,
+            poolEra: poolEra,
             vaultAccount: vaultPublickey,
-            poolState: liquidationPoolStatePublicKey,
+            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
+            poolState: poolState,
+            poolAssociatedTokenAccount: poolAssociatedTokenAccount,
             usdhMint: usdhMintPublickey,
-            priceForCollateral: solPriceAccount,
             history: historyPublicKey,
             payer: payerPublicKey,
-            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId,
-            feePool: hedgeStakingPoolPublicKey,
+            payerAssociatedTokenAccount: payerAssociatedTokenAccount,
+            feePool: feePool,
+            feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
             liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
-            newEra: newEraPublicKey
+            newEra: newEraPublicKey,
+            tokenProgram: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            rent: web3_js.SYSVAR_RENT_PUBKEY
         },
         signers: []
-    });
+    };
+    if (preload) {
+        return program.instruction.liquidateVaultPrepAccounts(payload);
+    }
+    return program.instruction.liquidateVault(payload);
 }
 
-async function refreshOraclePrice(program, provider, payer, overridePrice, overrideTime) {
-    const transaction = new web3_js.Transaction().add(await refreshOraclePriceInstruction(program, overridePrice, overrideTime));
+async function refreshOraclePrice(program, provider, payer, collateralType, network, overridePrice, overrideTime) {
+    const transaction = new web3_js.Transaction().add(await refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime));
     return await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts);
 }
-async function refreshOraclePriceInstruction(program, overridePrice, overrideTime) {
+async function refreshOraclePriceInstruction(program, collateralType, network, overridePrice, overrideTime) {
     const enc = new TextEncoder();
-    const [oracleInfoAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY);
-    const [collateralPriceAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode('SOL'), enc.encode('Price')], HEDGE_PROGRAM_PUBLICKEY);
+    const [oracleInfoAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('Oracle')], HEDGE_PROGRAM_PUBLICKEY);
+    const [collateralStateAccount] = await web3_js.PublicKey.findProgramAddress([enc.encode(collateralType), enc.encode('State')], HEDGE_PROGRAM_PUBLICKEY);
     return program.instruction.refreshOraclePrice(new anchor.BN(overridePrice !== null && overridePrice !== void 0 ? overridePrice : web3_js.LAMPORTS_PER_SOL * 150), // override usd/sol price
     new anchor.BN(overrideTime !== null && overrideTime !== void 0 ? overrideTime : Math.floor(Date.now() / 1000)), // override override time
     {
         accounts: {
             oracleInfoAccount: oracleInfoAccount,
-            collateralPriceAccount: collateralPriceAccount,
-            oracleChainlink: web3_js.SystemProgram.programId,
-            oraclePyth: web3_js.SystemProgram.programId,
-            oracleSwitchboard: web3_js.SystemProgram.programId,
+            collateralStateAccount: collateralStateAccount,
+            oracleChainlink: chainlinkAccunts[network],
+            oraclePyth: pythAccounts[network],
+            oracleSwitchboard: switchboardAccounts[network],
             systemProgram: web3_js.SystemProgram.programId
         },
         signers: []
     });
 }
+var Cluster;
+(function (Cluster) {
+    Cluster["Testing"] = "Testing";
+    Cluster["Devnet"] = "Devnet";
+    Cluster["MainnetBeta"] = "MainnetBeta";
+})(Cluster || (Cluster = {}));
+const pythAccounts = {
+    Testing: web3_js.SystemProgram.programId,
+    Devnet: new web3_js.PublicKey('J83w4HKfqxwcq3BEMMkPFSppX3gqekLyLJBexebFVkix'),
+    MainnetBeta: new web3_js.PublicKey('H6ARHf6YXhGYeQfUzQNGk6rDNnLBQKrenN712K4AQJEG')
+};
+const chainlinkAccunts = {
+    Testing: web3_js.SystemProgram.programId,
+    Devnet: new web3_js.PublicKey('FmAmfoyPXiA8Vhhe6MZTr3U6rZfEZ1ctEHay1ysqCqcf'),
+    MainnetBeta: web3_js.SystemProgram.programId // CHAINLINK NOT ON MAINNET YET
+};
+const switchboardAccounts = {
+    Testing: web3_js.SystemProgram.programId,
+    // Devnet: new PublicKey('GvDMxPzN1sCj7L26YDK2HnMRXEQmQ2aemov8YBtPS7vR'),
+    Devnet: new web3_js.PublicKey('DpoK8Zz69APV9ntjuY9C4LZCxANYMV56M2cbXEdkjxME'),
+    MainnetBeta: web3_js.SystemProgram.programId // Switchboard V2 NOT ON MAINNET YET
+};
 
 /**
    * Convert a U128 to a Decimal
@@ -1899,7 +2160,6 @@ class VaultAccount {
         this.debt = vault.debt.toNumber();
         this.deposited = vault.deposited.toNumber();
         this.minCollateralRatio = DecimalFromU128(vault.minCollateralRatio);
-        this.liquidationPrice = vault.liquidationPrice.toNumber();
         this.vaultStatus = Object.keys(vault.vaultStatus)[0];
     }
     /**
@@ -2025,7 +2285,7 @@ class LiquidationPoolEra {
         this.liquidyPoolEra = liquidyPoolEra;
         this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber();
         this.product = DecimalFromU128(liquidyPoolEra.productBytes);
-        this.sum = DecimalFromU128(liquidyPoolEra.sumBytes);
+        this.sum = liquidyPoolEra.sumBytes.map((sumBytes) => { return DecimalFromU128(sumBytes); });
         this.hedgeRewardsAccumulator = DecimalFromU128(liquidyPoolEra.hedgeRewardsAccumulatorBytes);
         this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber();
     }
@@ -2041,47 +2301,35 @@ class LiquidationPoolState {
 }
 
 class LiquidationPosition {
-    constructor(poolPositionInfo, key, era, liquidationPoolState) {
+    constructor(poolPositionInfo, key) {
         this.publicKey = key;
         this.eraPublicKey = poolPositionInfo.era;
-        this.era = era;
-        this.liquidationPoolState = liquidationPoolState;
         this.ownerAccount = poolPositionInfo.ownerAccount;
         this.deposit = poolPositionInfo.deposit.toNumber();
         this.closedUsdh = poolPositionInfo.closedUsdh.toNumber();
-        this.closedSol = poolPositionInfo.closedSol.toNumber();
         this.timestampOpened = poolPositionInfo.timestampOpened.toNumber();
         this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
-        this.productSnapshot = DecimalFromU128(poolPositionInfo.productSnapshotBytes);
-        this.sumSnapshot = DecimalFromU128(poolPositionInfo.sumSnapshotBytes);
+        this.productSnapshotEntry = DecimalFromU128(poolPositionInfo.productSnapshotEntry);
+        this.productSnapshotClosed = DecimalFromU128(poolPositionInfo.productSnapshotClosed);
+        this.sumSnapshotsEntry = poolPositionInfo.sumSnapshotsEntry.map((sum) => { return DecimalFromU128(sum); });
+        this.sumSnapshotsClosed = poolPositionInfo.sumSnapshotsClosed.map((sum) => { return DecimalFromU128(sum); });
         this.hedgeRewardsSnapshot = DecimalFromU128(poolPositionInfo.hedgeRewardsSnapshotAccum);
         this.open = poolPositionInfo.state.open !== undefined;
     }
-    getUsdhAvailable() {
-        return (this.era.product.div(this.productSnapshot)).mul(new Decimal__default["default"](this.deposit));
-    }
-    getSolAvailable() {
-        return this.era.sum.minus(this.sumSnapshot).div(this.productSnapshot).mul(new Decimal__default["default"](this.deposit)).floor();
+    getUsdhAvailable(era) {
+        return (era.product.div(this.productSnapshotEntry)).mul(new Decimal__default["default"](this.deposit));
     }
-    getHedgeAvailable() {
-        const LiquidationPoolTotalSupply = 2000000.0 * web3_js.LAMPORTS_PER_SOL;
-        const hedgeRewardsSinceLastUpdate = hedgeRewardsDecay(LiquidationPoolTotalSupply, this.liquidationPoolState.hedgeInitRewardsTimestamp * 1000, this.era.hedgeRewardsTimestamp * 1000, Date.now(), 365 * 1000);
-        if (this.era.totalDeposits === 0) {
-            return new Decimal__default["default"](0);
-        }
-        const rewardsPerToken = this.era.product.mul(new Decimal__default["default"](hedgeRewardsSinceLastUpdate / this.era.totalDeposits));
-        const newAccumulator = rewardsPerToken.add(new Decimal__default["default"](this.era.hedgeRewardsAccumulator));
-        const hedgeAvailable = (newAccumulator.minus(this.hedgeRewardsSnapshot)).mul(new Decimal__default["default"](this.deposit)).div(new Decimal__default["default"](this.productSnapshot));
-        return hedgeAvailable;
+    getSolAvailable(era) {
+        return era.sum[0].minus(this.sumSnapshotsEntry[0]).div(this.productSnapshotEntry).mul(new Decimal__default["default"](this.deposit)).floor();
     }
 }
-function hedgeRewardsDecay(supply, birthTime, timeIn, timeOut, halfLifeInDays) {
-    const timeInOffsetStart = timeIn - birthTime;
-    const timeOutOffsetStart = timeOut - birthTime;
-    const halfLife = -1 * Math.log(2) / (halfLifeInDays * 60 * 60 * 24);
-    const awardedTokens = supply * (Math.pow(Math.E, halfLife * timeInOffsetStart) - Math.pow(Math.E, halfLife * timeOutOffsetStart));
-    return awardedTokens;
-}
+// function hedgeRewardsDecay (supply: number, birthTime: number, timeIn: number, timeOut: number, halfLifeInDays: number): number {
+//   const timeInOffsetStart = timeIn - birthTime
+//   const timeOutOffsetStart = timeOut - birthTime
+//   const halfLife = -1 * Math.log(2) / (halfLifeInDays * 60 * 60 * 24)
+//   const awardedTokens = supply * (Math.pow(Math.E, halfLife * timeInOffsetStart) - Math.pow(Math.E, halfLife * timeOutOffsetStart))
+//   return awardedTokens
+// }
 
 exports.CHAINLINK_SOL_USD_ID = CHAINLINK_SOL_USD_ID;
 exports.CHAINLINK_SOL_USD_PUBLICKEY = CHAINLINK_SOL_USD_PUBLICKEY;
@@ -2095,20 +2343,27 @@ exports.StakingPool = StakingPool;
 exports.StakingPoolPosition = StakingPoolPosition;
 exports.VaultAccount = VaultAccount;
 exports.VaultHistoryEvent = VaultHistoryEvent;
+exports.claimLiquidationPoolPosition = claimLiquidationPoolPosition;
+exports.claimLiquidationPoolPositionInstruction = claimLiquidationPoolPositionInstruction;
+exports.closeLiquidationPoolPosition = closeLiquidationPoolPosition;
+exports.closeLiquidationPoolPositionInstruction = closeLiquidationPoolPositionInstruction;
 exports.createStakingPool = createStakingPool;
 exports.createStakingPoolInstruction = createStakingPoolInstruction;
 exports.createVault = createVault;
 exports.createVaultInstruction = createVaultInstruction;
+exports.depositLiquidationPool = depositLiquidationPool;
+exports.depositLiquidationPoolInstruction = depositLiquidationPoolInstruction;
 exports.depositStakingPool = depositStakingPool;
 exports.depositStakingPoolInstruction = depositStakingPoolInstruction;
 exports.depositVault = depositVault;
 exports.depositVaultInstruction = depositVaultInstruction;
 exports.findAssociatedTokenAddress = findAssociatedTokenAddress;
+exports.findVaultAddress = findVaultAddress;
+exports.getCollateralStateAccountPublicKey = getCollateralStateAccountPublicKey;
 exports.getHedgeMintPublicKey = getHedgeMintPublicKey;
 exports.getLiquidationPoolStatePublicKey = getLiquidationPoolStatePublicKey;
 exports.getLiquidationPoolUsdhAccountPublicKey = getLiquidationPoolUsdhAccountPublicKey;
 exports.getPoolPublicKeyForMint = getPoolPublicKeyForMint;
-exports.getSolCollateralPriceAccountPublicKey = getSolCollateralPriceAccountPublicKey;
 exports.getUsdhMintPublicKey = getUsdhMintPublicKey;
 exports.getVaultSystemStatePublicKey = getVaultSystemStatePublicKey;
 exports.liquidateVault = liquidateVault;