hedge-web3 0.1.0 → 0.1.4

package/lib/index.js

@@ -0,0 +1,1976 @@
+'use strict';
+
+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 Decimal = require('decimal.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var Decimal__default = /*#__PURE__*/_interopDefaultLegacy(Decimal);
+
+const HEDGE_PROGRAM_ID = 'fff6FuPWrBPzFHeWwtBQaPjKvMvW27w8Jf4P7SSoueX';
+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);
+async function getLiquidationPoolStatePublicKey() {
+    const enc = new TextEncoder();
+    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [poolPublicKey, bump];
+}
+async function getLiquidationPoolUsdhAccountPublicKey() {
+    const enc = new TextEncoder();
+    const [poolPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [poolPublicKey, bump];
+}
+async function getUsdhMintPublicKey() {
+    const enc = new TextEncoder();
+    const [findMintPublicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [findMintPublicKey, bump];
+}
+async function getVaultSystemStatePublicKey() {
+    const enc = new TextEncoder();
+    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [publicKey, bump];
+}
+async function getHedgeMintPublicKey() {
+    const enc = new TextEncoder();
+    const [publicKey, bump] = await web3_js.PublicKey.findProgramAddress([enc.encode('HEDGEMintV1')], HEDGE_PROGRAM_PUBLICKEY);
+    return [publicKey, bump];
+}
+async function getPoolPublicKeyForMint(mintPublicKey) {
+    const enc = new TextEncoder();
+    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 findAssociatedTokenAddress(walletAddress, tokenMintAddress) {
+    return (await web3_js.PublicKey.findProgramAddress([
+        walletAddress.toBuffer(),
+        splToken.TOKEN_PROGRAM_ID.toBuffer(),
+        tokenMintAddress.toBuffer()
+    ], splToken.ASSOCIATED_TOKEN_PROGRAM_ID))[0];
+}
+
+var Constants = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HEDGE_PROGRAM_ID: HEDGE_PROGRAM_ID,
+    HEDGE_PROGRAM_PUBLICKEY: HEDGE_PROGRAM_PUBLICKEY,
+    CHAINLINK_SOL_USD_ID: CHAINLINK_SOL_USD_ID,
+    CHAINLINK_SOL_USD_PUBLICKEY: CHAINLINK_SOL_USD_PUBLICKEY,
+    getLiquidationPoolStatePublicKey: getLiquidationPoolStatePublicKey,
+    getLiquidationPoolUsdhAccountPublicKey: getLiquidationPoolUsdhAccountPublicKey,
+    getUsdhMintPublicKey: getUsdhMintPublicKey,
+    getVaultSystemStatePublicKey: getVaultSystemStatePublicKey,
+    getHedgeMintPublicKey: getHedgeMintPublicKey,
+    getPoolPublicKeyForMint: getPoolPublicKeyForMint,
+    findAssociatedTokenAddress: findAssociatedTokenAddress
+});
+
+const vaultIdl = {
+    version: '0.1.0',
+    name: 'vault',
+    instructions: [
+        {
+            name: 'initHedgeFoundation',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolEra',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'poolUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'founder',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'hedgeMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'founderAssociatedHedgeTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'oracleChainlink',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'oraclePyth',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'oracleSwitchboard',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'rent',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splAssociatedTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'bump1',
+                    type: 'u8'
+                },
+                {
+                    name: 'bump2',
+                    type: 'u8'
+                }
+            ]
+        },
+        {
+            name: 'createStakingPool',
+            accounts: [
+                {
+                    name: 'signer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'pool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'stakedTokenMintInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'poolAssociatedStakedTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolAssociatedUsdhTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'rent',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splAssociatedTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'bump1',
+                    type: 'u8'
+                },
+                {
+                    name: 'poolSeedPhraseInput',
+                    type: 'string'
+                },
+                {
+                    name: 'totalRewards',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        },
+        {
+            name: 'depositStakingPool',
+            accounts: [
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'pool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolPosition',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'payerAssociatedStakedTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolAssociatedStakedTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'stakeAmount',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        },
+        {
+            name: 'withdrawStakingPool',
+            accounts: [
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'pool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolPosition',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'hedgeMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'stakedTokenMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'payerAssociatedStakedTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'payerAssociatedHedgeAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'payerAssociatedUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolAssociatedStakedTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolAssociatedUsdhTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        },
+        {
+            name: 'createVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vault',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'depositAmount',
+                    type: 'u64'
+                },
+                {
+                    name: 'minCollateralRatio',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'depositVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'vaultOwner',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'depositAmount',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'withdrawVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'chainlinkFeedAccount',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultOwner',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'withdrawAmount',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideSolPrice',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'loanVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'feePool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'feePoolAssociatedUsdhTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultOwner',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'ownerUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'chainlinkFeedAccount',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'loanAmount',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideSolPrice',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'repayVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultOwner',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'ownerUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'repayAmount',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'redeemVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'feePool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'feePoolAssociatedUsdhTokenAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'payerUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'chainlinkFeedAccount',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'redeemPayUsdh',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideSolPrice',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        },
+        {
+            name: 'depositLiquidityPool',
+            accounts: [
+                {
+                    name: 'poolState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolEra',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolPosition',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'ownerUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'depositAmount',
+                    type: 'u64'
+                },
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        },
+        {
+            name: 'liquidateVault',
+            accounts: [
+                {
+                    name: 'vaultSystemState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'vaultAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'feePool',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'usdhMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolEra',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'newEra',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'chainlinkFeedAccount',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'history',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'overrideSolPrice',
+                    type: 'u64'
+                }
+            ]
+        },
+        {
+            name: 'withdrawLiquidity',
+            accounts: [
+                {
+                    name: 'poolState',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolEra',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolPosition',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'poolUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'payer',
+                    isMut: true,
+                    isSigner: true
+                },
+                {
+                    name: 'ownerUsdhAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'hedgeMint',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'payerAssociatedHedgeAccount',
+                    isMut: true,
+                    isSigner: false
+                },
+                {
+                    name: 'rent',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'splAssociatedTokenProgramInfo',
+                    isMut: false,
+                    isSigner: false
+                },
+                {
+                    name: 'systemProgram',
+                    isMut: false,
+                    isSigner: false
+                }
+            ],
+            args: [
+                {
+                    name: 'overrideCurrentTime',
+                    type: 'i64'
+                }
+            ]
+        }
+    ],
+    accounts: [
+        {
+            name: 'StakingPool',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'deposits',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'bump',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'seedPhrase',
+                        type: 'string'
+                    },
+                    {
+                        name: 'hedgeRewardAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'usdhFeeAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'solFeeAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'startTime',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'lastTransactionTime',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'halfLifeInDays',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'totalHedgeReward',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'stakedTokenMint',
+                        type: 'publicKey'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'StakingPoolPosition',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'state',
+                        type: {
+                            defined: 'PositionState'
+                        }
+                    },
+                    {
+                        name: 'owner',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'pool',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'deposited',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'startHedgeRewardAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'startUsdhFeeAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'startSolFeeAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'timestampOpened',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'timestampClosed',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'closedRewardedTokens',
+                        type: 'u64'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'VaultSystemState',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'lastRedeemFeeBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'lastRedeemTimestamp',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'totalCollateral',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'totalUsdhSupply',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'totalVaults',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'totalVaultsClosed',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'debtRedistributionProduct',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'collateralRedistributionAccumulator',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'debtRedistributionError',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'bumpVaultState',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'bumpPoolState',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'bumpMint',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'bumpUsdhPoolAccount',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'authority',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'oracleChainlink',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'oraclePyth',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'oracleSwitchboard',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'hedgeStakingPool',
+                        type: 'publicKey'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'Vault',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'vaultOwner',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'deposited',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'debt',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'vaultVersion',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'liquidationPrice',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'minCollateralRatio',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'debtProductSnapshotBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'collateralAccumulatorSnapshotBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'collateralType',
+                        type: {
+                            defined: 'CurrencyType'
+                        }
+                    },
+                    {
+                        name: 'debtType',
+                        type: {
+                            defined: 'CurrencyType'
+                        }
+                    },
+                    {
+                        name: 'vaultStatus',
+                        type: {
+                            defined: 'VaultStatus'
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            name: 'VaultHistoryEvent',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'vaultAccount',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'actorAccount',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'usdSolPrice',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'usdhDebtBefore',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'usdhDebtAfter',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'solBalanceBefore',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'solBalanceAfter',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'minCollateralRatioBefore',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'minCollateralRatioAfter',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'vaultStateBefore',
+                        type: {
+                            defined: 'VaultStatus'
+                        }
+                    },
+                    {
+                        name: 'vaultStateAfter',
+                        type: {
+                            defined: 'VaultStatus'
+                        }
+                    },
+                    {
+                        name: 'timestamp',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'action',
+                        type: {
+                            defined: 'VaultHistoryAction'
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            name: 'LiquidationPoolState',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'currentEra',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'lifetimeDeposits',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeOpenedPositions',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeClosedPositions',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeVaultsLiquidated',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeVaultsRedistributed',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeSolPurchased',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'lifetimeSolClaimed',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'hedgeInitRewardsTimestamp',
+                        type: 'i64'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'LiquidationPoolEra',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'totalDeposits',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'productBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'sumBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'hedgeRewardsAccumulatorBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'hedgeRewardsTimestamp',
+                        type: 'i64'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'LiquidationPosition',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'state',
+                        type: {
+                            defined: 'PositionState'
+                        }
+                    },
+                    {
+                        name: 'era',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'ownerAccount',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'deposit',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'closedSol',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'closedUsdh',
+                        type: 'u64'
+                    },
+                    {
+                        name: 'productSnapshotBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'sumSnapshotBytes',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'hedgeRewardsSnapshotAccum',
+                        type: 'u128'
+                    },
+                    {
+                        name: 'timestampOpened',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'timestampClosed',
+                        type: 'i64'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'Aggregator',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'isInitialized',
+                        type: 'bool'
+                    },
+                    {
+                        name: 'version',
+                        type: 'u32'
+                    },
+                    {
+                        name: 'config',
+                        type: {
+                            defined: 'Config'
+                        }
+                    },
+                    {
+                        name: 'updatedAt',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'owner',
+                        type: 'publicKey'
+                    },
+                    {
+                        name: 'submissions',
+                        type: {
+                            array: [
+                                {
+                                    defined: 'Submission'
+                                },
+                                8
+                            ]
+                        }
+                    },
+                    {
+                        name: 'answer',
+                        type: {
+                            option: 'u128'
+                        }
+                    }
+                ]
+            }
+        }
+    ],
+    types: [
+        {
+            name: 'Config',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'oracles',
+                        type: {
+                            vec: 'publicKey'
+                        }
+                    },
+                    {
+                        name: 'minAnswerThreshold',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'stalenessThreshold',
+                        type: 'u8'
+                    },
+                    {
+                        name: 'decimals',
+                        type: 'u8'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'Submission',
+            type: {
+                kind: 'struct',
+                fields: [
+                    {
+                        name: 'timestamp',
+                        type: 'i64'
+                    },
+                    {
+                        name: 'value',
+                        type: 'u128'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'PositionState',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Open'
+                    },
+                    {
+                        name: 'Closed'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'CurrencyType',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Solana'
+                    },
+                    {
+                        name: 'Usdh'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'VaultStatus',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Open'
+                    },
+                    {
+                        name: 'Closed'
+                    },
+                    {
+                        name: 'Liquidated'
+                    },
+                    {
+                        name: 'Distributed'
+                    },
+                    {
+                        name: 'Redeemed'
+                    }
+                ]
+            }
+        },
+        {
+            name: 'VaultHistoryAction',
+            type: {
+                kind: 'enum',
+                variants: [
+                    {
+                        name: 'Create'
+                    },
+                    {
+                        name: 'Close'
+                    },
+                    {
+                        name: 'Liquidate'
+                    },
+                    {
+                        name: 'PartialLiquidate'
+                    },
+                    {
+                        name: 'Distributed'
+                    },
+                    {
+                        name: 'Redeem'
+                    },
+                    {
+                        name: 'TransferOwnership'
+                    },
+                    {
+                        name: 'Deposit'
+                    },
+                    {
+                        name: 'Withdraw'
+                    },
+                    {
+                        name: 'Loan'
+                    },
+                    {
+                        name: 'RepayCredit'
+                    }
+                ]
+            }
+        }
+    ],
+    errors: [
+        {
+            code: 6000,
+            name: 'AlreadyInitialized',
+            msg: 'This vault was already initialized'
+        },
+        {
+            code: 6001,
+            name: 'NotInitialized',
+            msg: 'This vault was not initialized'
+        },
+        {
+            code: 6002,
+            name: 'Overdraw',
+            msg: 'Cannot withdraw more than deposited'
+        },
+        {
+            code: 6003,
+            name: 'Overpaid',
+            msg: 'Cannot repay more than loaned'
+        },
+        {
+            code: 6004,
+            name: 'NotAuthorizedToCreateStakingPools',
+            msg: 'Signer not authorized to create new staking pools'
+        },
+        {
+            code: 6005,
+            name: 'BadSeed',
+            msg: 'Bad Seed'
+        }
+    ]
+};
+
+async function createVault(connection, payer, depositAmount, collateralRatio, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(connection, usdhMintPublickey, splToken.TOKEN_PROGRAM_ID, payer);
+    // 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(vaultSystemStatePublicKey, payer.publicKey, newVault.publicKey, history.publicKey, depositAmount, collateralRatio));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, newVault, history], confirmOptions);
+    return newVault.publicKey;
+}
+function createVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount, collateralRatio) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    const ix = program.instruction.createVault(new anchor.BN(depositAmount), new anchor.BN(collateralRatio), {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            vault: vaultPublicKey,
+            history: historyPublicKey,
+            payer: payerPublicKey,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+    return ix;
+}
+
+async function depositVault(connection, payer, vaultPublicKey, depositAmount, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(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(depositVaultInstruction(vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, depositAmount));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    return vaultPublicKey;
+}
+function depositVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublicKey, historyPublicKey, depositAmount) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    return program.instruction.depositVault(new anchor.BN(depositAmount), {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            vaultAccount: vaultPublicKey,
+            history: historyPublicKey,
+            vaultOwner: payerPublicKey,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function withdrawVault(connection, payer, vaultPublicKey, withdrawAmount, chainlinkOverridePrice, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(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(withdrawVaultInstruction(vaultSystemStatePublicKey, payer.publicKey, vaultPublicKey, history.publicKey, withdrawAmount, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    return vaultPublicKey;
+}
+function withdrawVaultInstruction(vaultSystemStatePublicKey, payerPublicKey, vaultPublickey, historyPublicKey, withdrawAmount, chainlinkOverridePrice) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    return program.instruction.withdrawVault(new anchor.BN(withdrawAmount), new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : 200 * web3_js.LAMPORTS_PER_SOL), {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            vaultAccount: vaultPublickey,
+            history: historyPublicKey,
+            vaultOwner: payerPublicKey,
+            chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function loanVault(connection, payer, vaultPublicKey, loanAmount, chainlinkOverridePrice, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(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 history = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await loanVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, loanAmount, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    return vaultPublicKey;
+}
+async function loanVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, loanAmount, chainlinkOverridePrice) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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.loanVault(new anchor.BN(loanAmount), new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : web3_js.LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            vaultAccount: vaultPublickey,
+            history: historyPublicKey,
+            feePool: hedgeStakingPoolPublicKey,
+            feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+            usdhMint: usdhMintPublickey,
+            vaultOwner: payerPublicKey,
+            ownerUsdhAccount: ownerUsdhAccount,
+            chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function repayVault(connection, payer, vaultPublicKey, repayAmount, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(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 history = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await repayVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    return vaultPublicKey;
+}
+async function repayVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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,
+            vaultAccount: vaultPublickey,
+            history: historyPublicKey,
+            feePool: hedgeStakingPoolPublicKey,
+            feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+            usdhMint: usdhMintPublickey,
+            vaultOwner: payerPublicKey,
+            ownerUsdhAccount: ownerUsdhAccount,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function redeemVault(connection, payer, vaultPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime, confirmOptions) {
+    const [usdhMintPublickey] = await getUsdhMintPublicKey();
+    const USDH = new splToken.Token(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 history = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await redeemVaultInstruction(payer.publicKey, payerUsdhAccount.address, vaultPublicKey, history.publicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history], confirmOptions);
+    return vaultPublicKey;
+}
+async function redeemVaultInstruction(payerPublicKey, ownerUsdhAccount, vaultPublickey, historyPublicKey, repayAmount, chainlinkOverridePrice, transactionOverrideTime) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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.redeemVault(new anchor.BN(repayAmount), new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : 150 * web3_js.LAMPORTS_PER_SOL), // override usd/sol price
+    new anchor.BN(transactionOverrideTime !== null && transactionOverrideTime !== void 0 ? transactionOverrideTime : (Date.now() / 1000)), // override start time
+    {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            vaultAccount: vaultPublickey,
+            history: historyPublicKey,
+            feePool: hedgeStakingPoolPublicKey,
+            feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
+            usdhMint: usdhMintPublickey,
+            payer: payerPublicKey,
+            payerUsdhAccount: ownerUsdhAccount,
+            chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function liquidateVault(connection, payer, vaultPublicKey, chainlinkOverridePrice, confirmOptions) {
+    const history = web3_js.Keypair.generate();
+    const newEra = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await liquidateVaultInstruction(payer.publicKey, vaultPublicKey, history.publicKey, newEra.publicKey, chainlinkOverridePrice));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, history, newEra], confirmOptions);
+    return vaultPublicKey;
+}
+async function liquidateVaultInstruction(payerPublicKey, vaultPublickey, historyPublicKey, newEraPublicKey, chainlinkOverridePrice) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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 poolStateInfo = await program.account.liquidationPoolState.fetch(liquidationPoolStatePublicKey);
+    return program.instruction.liquidateVault(new anchor.BN(chainlinkOverridePrice !== null && chainlinkOverridePrice !== void 0 ? chainlinkOverridePrice : web3_js.LAMPORTS_PER_SOL * 150), // override usd/sol price
+    {
+        accounts: {
+            vaultSystemState: vaultSystemStatePublicKey,
+            poolEra: poolStateInfo.currentEra,
+            vaultAccount: vaultPublickey,
+            poolState: liquidationPoolStatePublicKey,
+            usdhMint: usdhMintPublickey,
+            chainlinkFeedAccount: CHAINLINK_SOL_USD_PUBLICKEY,
+            history: historyPublicKey,
+            payer: payerPublicKey,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId,
+            feePool: hedgeStakingPoolPublicKey,
+            poolUsdhAccount: liquidationPoolUsdhAccountPublickey,
+            newEra: newEraPublicKey
+        },
+        signers: []
+    });
+}
+
+/**
+   * Convert a U128 to a Decimal
+   *
+   * On chain, u128s are used to store Decimal numbers. These values
+   * are simply stored as u128 where the actual value is divided by
+   * 1.0e+24. This gives 24 digits of percision on decimal numbers.
+   *
+   * Example: the number 1.5 is stored as a u128: 1.5 * 10^24
+   *
+   * @param value the value to be converted to Decimal
+   * @returns the converted value as a decimal.js object
+   */
+function DecimalFromU128(value) {
+    const adjustedValue = new Decimal__default["default"](value.toString());
+    return adjustedValue.div(new Decimal__default["default"]('1e+24'));
+}
+
+/**
+ * A class that represents an on-chian vault.
+ */
+class VaultAccount {
+    constructor(vault, publicKey) {
+        this.publicKey = publicKey;
+        this.vaultOwner = vault.vaultOwner;
+        this.debt = vault.debt.toNumber();
+        this.deposited = vault.deposited.toNumber();
+        this.minCollateralRatio = DecimalFromU128(vault.minCollateralRatio);
+        this.liquidationPrice = vault.liquidationPrice.toNumber();
+        this.minCollateralRatio = vault.minCollateralRatio.toNumber();
+        this.vaultStatus = Object.keys(vault.vaultStatus)[0];
+    }
+    /**
+     * Check if some `PublicKey` is the owner
+     *
+     * @param publicKey the publicKey to check against the vault owner
+     * @returns true if publicKey matches the owner publicKey
+     */
+    isOwnedBy(publicKey) {
+        return publicKey.toString() === this.vaultOwner.toString();
+    }
+    /**
+     * Get the collateral value in SOL
+     *
+     * @returns collateral value in SOL
+     */
+    inSol() {
+        return this.deposited / web3_js.LAMPORTS_PER_SOL;
+    }
+    /**
+     * Get the debt value in USDH
+     *
+     * @returns debt value in USDH
+     */
+    inUsd() {
+        return this.debt / web3_js.LAMPORTS_PER_SOL;
+    }
+    /**
+     * Pretty print the vault publickey for easy display
+     *
+     * @returns example: `1b6ca...azy71s`
+     */
+    toDisplayString() {
+        return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey.toString().substring(this.publicKey.toString().length - 6)}`;
+    }
+}
+
+var Vaults = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createVault: createVault,
+    createVaultInstruction: createVaultInstruction,
+    depositVault: depositVault,
+    depositVaultInstruction: depositVaultInstruction,
+    withdrawVault: withdrawVault,
+    withdrawVaultInstruction: withdrawVaultInstruction,
+    loanVault: loanVault,
+    loanVaultInstruction: loanVaultInstruction,
+    repayVault: repayVault,
+    repayVaultInstruction: repayVaultInstruction,
+    redeemVault: redeemVault,
+    redeemVaultInstruction: redeemVaultInstruction,
+    liquidateVault: liquidateVault,
+    liquidateVaultInstruction: liquidateVaultInstruction,
+    VaultAccount: VaultAccount
+});
+
+function parseAnchorErrors(error) {
+    const idlErrors = anchor.parseIdlErrors(vaultIdl);
+    const parsedError = anchor.ProgramError.parse(error, idlErrors);
+    if (parsedError !== null) {
+        throw parsedError;
+    }
+    throw error;
+}
+
+async function createStakingPool(connection, payer, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime, confirmOptions) {
+    const transaction = new web3_js.Transaction().add(await createStakingPoolInstruction(payer.publicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions).catch(parseAnchorErrors);
+    const [poolPublickey] = await getPoolPublicKeyForMint(mintPublicKey);
+    return poolPublickey;
+}
+async function createStakingPoolInstruction(payerPublicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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);
+    return program.instruction.createStakingPool(poolBump, poolSeedPhrase, new anchor.BN(hedgeTokensToBeMinted), new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), {
+        accounts: {
+            signer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublickey,
+            stakedTokenMintInfo: mintPublicKey,
+            usdhMint: usdhMintPublickey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function depositStakingPool(connection, payer, mintPublicKey, depositAmount, overrideStartTime, confirmOptions) {
+    const poolPosition = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await depositStakingPoolInstruction(payer.publicKey, poolPosition.publicKey, mintPublicKey, depositAmount, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer, poolPosition], confirmOptions).catch(parseAnchorErrors);
+    return poolPosition.publicKey;
+}
+async function depositStakingPoolInstruction(payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    const [poolPublickey] = await getPoolPublicKeyForMint(stakedTokenMintPublicKey);
+    const poolAssociatedStakedTokenAccount = await findAssociatedTokenAddress(poolPublickey, stakedTokenMintPublicKey);
+    const payersArbitraryTokenAccount = await findAssociatedTokenAddress(payerPublicKey, stakedTokenMintPublicKey);
+    return program.instruction.depositStakingPool(new anchor.BN(depositAmount), new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            payer: payerPublicKey,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            stakedTokenMintInfo: stakedTokenMintPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            payerAssociatedStakedTokenAccount: payersArbitraryTokenAccount,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+async function withdrawStakingPool(connection, payer, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime, confirmOptions) {
+    const poolPosition = web3_js.Keypair.generate();
+    const transaction = new web3_js.Transaction().add(await withdrawStakingPoolInstruction(payer.publicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime));
+    await web3_js.sendAndConfirmTransaction(connection, transaction, [payer], confirmOptions).catch(parseAnchorErrors);
+    return poolPosition.publicKey;
+}
+async function withdrawStakingPoolInstruction(payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
+    const program = new anchor.Program(vaultIdl, HEDGE_PROGRAM_ID);
+    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);
+    return program.instruction.withdrawStakingPool(new anchor.BN(overrideStartTime !== null && overrideStartTime !== void 0 ? overrideStartTime : Date.now() / 1000), // override current time
+    {
+        accounts: {
+            payer: payerPublicKey,
+            vaultSystemState: vaultSystemStatePublicKey,
+            pool: poolPublickey,
+            poolPosition: poolPositionPublicKey,
+            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
+            poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
+            payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
+            payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
+            payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
+            hedgeMint: hedgeMintPublickey,
+            stakedTokenMint: stakedTokenMintPublicKey,
+            usdhMint: usdhMintPublickey,
+            rent: web3_js.SYSVAR_RENT_PUBKEY,
+            splTokenProgramInfo: splToken.TOKEN_PROGRAM_ID,
+            splAssociatedTokenProgramInfo: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: web3_js.SystemProgram.programId
+        },
+        signers: []
+    });
+}
+
+var StakingPools = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createStakingPool: createStakingPool,
+    createStakingPoolInstruction: createStakingPoolInstruction,
+    depositStakingPool: depositStakingPool,
+    depositStakingPoolInstruction: depositStakingPoolInstruction,
+    withdrawStakingPool: withdrawStakingPool,
+    withdrawStakingPoolInstruction: withdrawStakingPoolInstruction
+});
+
+exports.Constants = Constants;
+exports.DecimalFromU128 = DecimalFromU128;
+exports.StakingPool = StakingPools;
+exports.Vaults = Vaults;
+//# sourceMappingURL=index.js.map