hedge-web3 0.1.14 → 0.1.17

package/lib/index.js

@@ -1,2383 +1,37 @@
-'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 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 }; }
-
-var Decimal__default = /*#__PURE__*/_interopDefaultLegacy(Decimal);
-
-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: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false
-                },
-                {
-                    name: 'associatedTokenProgram',
-                    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: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false
-                },
-                {
-                    name: 'associatedTokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    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: 'tokenProgram',
-                    isMut: false,
-                    isSigner: false
-                },
-                {
-                    name: 'associatedTokenProgram',
-                    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'
-        }
-    ]
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-
-function parseAnchorErrors(error) {
-    const idlErrors = anchor.parseIdlErrors(vaultIdl);
-    const parsedError = anchor.ProgramError.parse(error, idlErrors);
-    if (parsedError !== null) {
-        throw parsedError;
-    }
-    throw error;
-}
-
-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] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolStateV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return poolPublicKey;
-}
-async function getLiquidationPoolUsdhAccountPublicKey() {
-    const [poolPublicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('LiquidationPoolUSDHAccountV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return poolPublicKey;
-}
-async function getUsdhMintPublicKey() {
-    const [findMintPublicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('UsdhMintV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return findMintPublicKey;
-}
-async function getVaultSystemStatePublicKey() {
-    const [publicKey] = await web3_js.PublicKey.findProgramAddress([enc.encode('VaultSystemStateV1')], HEDGE_PROGRAM_PUBLICKEY);
-    return publicKey;
-}
-async function getHedgeMintPublicKey() {
-    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 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([
-        walletAddress.toBuffer(),
-        splToken.TOKEN_PROGRAM_ID.toBuffer(),
-        tokenMintAddress.toBuffer()
-    ], splToken.ASSOCIATED_TOKEN_PROGRAM_ID))[0];
-}
-
-async function createStakingPool(program, provider, payer, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
-    const transaction = new web3_js.Transaction().add(await createStakingPoolInstruction(program, payer.publicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime));
-    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
-    const [poolPublickey] = await getPoolPublicKeyForMint(mintPublicKey);
-    return poolPublickey;
-}
-async function createStakingPoolInstruction(program, payerPublicKey, mintPublicKey, hedgeTokensToBeMinted, overrideStartTime) {
-    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,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-async function depositStakingPool(program, provider, payer, mintPublicKey, depositAmount, overrideStartTime) {
-    const poolPosition = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await depositStakingPoolInstruction(program, payer.publicKey, poolPosition.publicKey, mintPublicKey, depositAmount, overrideStartTime));
-    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer, poolPosition], provider.opts).catch(parseAnchorErrors);
-    return poolPosition.publicKey;
-}
-async function depositStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, depositAmount, overrideStartTime) {
-    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,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-async function withdrawStakingPool(program, provider, payer, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
-    const poolPosition = web3_js.Keypair.generate();
-    const transaction = new web3_js.Transaction().add(await withdrawStakingPoolInstruction(program, payer.publicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime));
-    await web3_js.sendAndConfirmTransaction(provider.connection, transaction, [payer], provider.opts).catch(parseAnchorErrors);
-    return poolPosition.publicKey;
-}
-async function withdrawStakingPoolInstruction(program, payerPublicKey, poolPositionPublicKey, stakedTokenMintPublicKey, overrideStartTime) {
-    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: {
-            payer: payerPublicKey,
-            vaultSystemState: vaultSystemStatePublicKey,
-            pool: poolPublickey,
-            poolPosition: poolPositionPublicKey,
-            poolAssociatedStakedTokenAccount: poolAssociatedStakedTokenAccount,
-            poolAssociatedUsdhTokenAccount: poolAssociatedUsdhTokenAccount,
-            payerAssociatedStakedTokenAccount: payerAssociatedStakedTokenAccount,
-            payerAssociatedHedgeAccount: payerAssociatedHedgeAccount,
-            payerAssociatedUsdhAccount: payerAssociatedUsdhAccount,
-            communityAssociatedHedgeTokenAccount: communityHedgeTokenAccount,
-            hedgeMint: hedgeMintPublickey,
-            stakedTokenMint: stakedTokenMintPublicKey,
-            usdhMint: usdhMintPublickey,
-            rent: web3_js.SYSVAR_RENT_PUBKEY,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            associatedTokenProgram: splToken.ASSOCIATED_TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-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 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;
-}
-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,
-            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, 
-// 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 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;
-}
-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,
-            collateralStateAccount: collateralStateAccountPublicKey,
-            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
-            collateralTokenMint: collateralMint,
-            vault: vaultPublicKey,
-            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-            history: historyPublicKey,
-            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 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 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, destinationTokenAccount, vaultPublickey, vaultAssociatedCollateralPublicKey, collateralStateAccount, collateralAssociatedTokenAccount, historyPublicKey, withdrawAmount) {
-    return program.instruction.withdrawVault(new anchor.BN(withdrawAmount), {
-        accounts: {
-            vaultSystemState: vaultSystemStatePublicKey,
-            collateralStateAccount: collateralStateAccount,
-            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
-            vault: vaultPublickey,
-            vaultAssociatedTokenAccount: vaultAssociatedCollateralPublicKey,
-            history: historyPublicKey,
-            vaultOwner: payerPublicKey,
-            destinationTokenAccount: destinationTokenAccount,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-async function loanVault(program, provider, payer, vaultPublicKey, loanAmount) {
-    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, 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, 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);
-    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,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-async function repayVault(program, provider, payer, vaultPublicKey, repayAmount) {
-    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, 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, 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,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-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, 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, 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);
-    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,
-            collateralStateAccount: collateralStateAccount,
-            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
-            vault: vaultPublickey,
-            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-            history: historyPublicKey,
-            feePool: hedgeStakingPoolPublicKey,
-            feePoolAssociatedUsdhTokenAccount: hedgeStakingPoolAssociatedUsdhTokenAccount,
-            usdhMint: usdhMintPublickey,
-            payer: payerPublicKey,
-            payerUsdhAccount: payerUsdhAccount,
-            destinationTokenAccount: destinationTokenAccount,
-            tokenProgram: splToken.TOKEN_PROGRAM_ID,
-            systemProgram: web3_js.SystemProgram.programId
-        },
-        signers: []
-    });
-}
-
-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();
-    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, 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,
-            collateralStateAccount: collateralStateAccount,
-            collateralAssociatedTokenAccount: collateralAssociatedTokenAccount,
-            collateralMint: collateralMint,
-            poolEra: poolEra,
-            vaultAccount: vaultPublickey,
-            vaultAssociatedTokenAccount: vaultAssociatedTokenAccount,
-            poolState: poolState,
-            poolAssociatedTokenAccount: poolAssociatedTokenAccount,
-            usdhMint: usdhMintPublickey,
-            history: historyPublicKey,
-            payer: payerPublicKey,
-            payerAssociatedTokenAccount: payerAssociatedTokenAccount,
-            feePool: feePool,
-            feePoolAssociatedTokenAccount: feePoolAssociatedTokenAccount,
-            liquidationPoolUsdhAccount: liquidationPoolUsdhAccountPublickey,
-            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, 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, collateralType, network, overridePrice, overrideTime) {
-    const enc = new TextEncoder();
-    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,
-            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
-   *
-   * 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.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)}`;
-    }
-}
-
-class VaultHistoryEvent {
-    constructor(account, publicKey) {
-        this.account = account;
-        this.publicKey = publicKey;
-        this.actorAccount = account.actorAccount;
-        this.usdSolPrice = DecimalFromU128(account.usdSolPrice.toString());
-        this.usdhDebtBefore = account.usdhDebtBefore.toNumber();
-        this.usdhDebtAfter = account.usdhDebtAfter.toNumber();
-        this.solBalanceBefore = account.solBalanceBefore.toNumber();
-        this.solBalanceAfter = account.solBalanceAfter.toNumber();
-        this.minCollateralRatioBefore = DecimalFromU128(account.minCollateralRatioBefore);
-        this.minCollateralRatioAfter = DecimalFromU128(account.minCollateralRatioAfter);
-        this.vaultStateBefore = account.vaultStateBefore;
-        this.vaultStateAfter = account.vaultStateAfter;
-        this.timestamp = account.timestamp.toNumber();
-        this.action = account.action;
-    }
-}
-exports.VaultStatus = void 0;
-(function (VaultStatus) {
-    VaultStatus[VaultStatus["Open"] = 0] = "Open";
-    VaultStatus[VaultStatus["Closed"] = 1] = "Closed";
-    VaultStatus[VaultStatus["Liquidated"] = 2] = "Liquidated";
-    VaultStatus[VaultStatus["Distributed"] = 3] = "Distributed";
-    VaultStatus[VaultStatus["Redeemed"] = 4] = "Redeemed";
-})(exports.VaultStatus || (exports.VaultStatus = {}));
-exports.VaultHistoryAction = void 0;
-(function (VaultHistoryAction) {
-    VaultHistoryAction[VaultHistoryAction["Create"] = 0] = "Create";
-    VaultHistoryAction[VaultHistoryAction["Close"] = 1] = "Close";
-    VaultHistoryAction[VaultHistoryAction["Liquidate"] = 2] = "Liquidate";
-    VaultHistoryAction[VaultHistoryAction["PartialLiquidate"] = 3] = "PartialLiquidate";
-    VaultHistoryAction[VaultHistoryAction["Distributed"] = 4] = "Distributed";
-    VaultHistoryAction[VaultHistoryAction["Redeem"] = 5] = "Redeem";
-    VaultHistoryAction[VaultHistoryAction["TransferOwnership"] = 6] = "TransferOwnership";
-    VaultHistoryAction[VaultHistoryAction["Deposit"] = 7] = "Deposit";
-    VaultHistoryAction[VaultHistoryAction["Withdraw"] = 8] = "Withdraw";
-    VaultHistoryAction[VaultHistoryAction["Loan"] = 9] = "Loan";
-    VaultHistoryAction[VaultHistoryAction["RepayCredit"] = 10] = "RepayCredit";
-})(exports.VaultHistoryAction || (exports.VaultHistoryAction = {}));
-
-class StakingPool {
-    constructor(poolInfo, publicKey) {
-        this.poolInfo = poolInfo;
-        this.publicKey = publicKey;
-        this.deposits = poolInfo.deposits.toNumber();
-        // this.totalFeesNow = poolInfo.totalFeesNow.toNumber()
-        // this.totalFeesPrevious = poolInfo.totalFeesPrevious.toNumber()
-        this.lastTransactionTime = poolInfo.lastTransactionTime.toNumber();
-        this.startTime = poolInfo.startTime.toNumber();
-        this.halfLifeInDays = poolInfo.halfLifeInDays.toNumber();
-        this.totalHedgeReward = poolInfo.totalHedgeReward.toNumber();
-        this.hedgeRewardAccumulator = DecimalFromU128(poolInfo.hedgeRewardAccumulator);
-        this.usdhFeeAccumulator = DecimalFromU128(poolInfo.usdhFeeAccumulator);
-        this.solFeeAccumulator = DecimalFromU128(poolInfo.solFeeAccumulator);
-        // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
-    }
-}
-
-class StakingPoolPosition {
-    constructor(poolPositionInfo, key, stakingPool) {
-        this.poolPositionInfo = poolPositionInfo;
-        this.publicKey = key;
-        this.pool = stakingPool;
-        this.owner = poolPositionInfo.owner;
-        this.deposited = poolPositionInfo.deposited.toNumber();
-        this.timestampOpened = poolPositionInfo.timestampOpened.toNumber();
-        this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
-        this.closedRewardedTokens = poolPositionInfo.closedRewardedTokens.toNumber();
-        this.startHedgeRewardAccumulator = DecimalFromU128(poolPositionInfo.startHedgeRewardAccumulator);
-        this.startUsdhFeeAccumulator = DecimalFromU128(poolPositionInfo.startUsdhFeeAccumulator);
-        this.startSolFeeAccumulator = DecimalFromU128(poolPositionInfo.startSolFeeAccumulator);
-        this.open = poolPositionInfo.state.open !== undefined;
-    }
-    getCurrentUsdhFeeReward() {
-        return this.pool.usdhFeeAccumulator.minus(this.startUsdhFeeAccumulator).times(new Decimal__default["default"](this.deposited));
-    }
-}
-
-/**
- * Represents an on-chian pool era. In the event an era is depleted of deposits, a new era is
- * created to maintain each users contribution to the pool.
- */
-class LiquidationPoolEra {
-    constructor(liquidyPoolEra) {
-        this.liquidyPoolEra = liquidyPoolEra;
-        this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber();
-        this.product = DecimalFromU128(liquidyPoolEra.productBytes);
-        this.sum = liquidyPoolEra.sumBytes.map((sumBytes) => { return DecimalFromU128(sumBytes); });
-        this.hedgeRewardsAccumulator = DecimalFromU128(liquidyPoolEra.hedgeRewardsAccumulatorBytes);
-        this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber();
-    }
-}
-
-class LiquidationPoolState {
-    constructor(liquidationPoolState) {
-        this.liquidationPoolState = liquidationPoolState;
-        this.lifetimeDeposits = liquidationPoolState.lifetimeDeposits.toNumber();
-        this.hedgeInitRewardsTimestamp = liquidationPoolState.hedgeInitRewardsTimestamp.toNumber();
-        // TODO Add the rest that are missing. Do we need them?
-    }
-}
-
-class LiquidationPosition {
-    constructor(poolPositionInfo, key) {
-        this.publicKey = key;
-        this.eraPublicKey = poolPositionInfo.era;
-        this.ownerAccount = poolPositionInfo.ownerAccount;
-        this.deposit = poolPositionInfo.deposit.toNumber();
-        this.closedUsdh = poolPositionInfo.closedUsdh.toNumber();
-        this.timestampOpened = poolPositionInfo.timestampOpened.toNumber();
-        this.timestampClosed = poolPositionInfo.timestampClosed.toNumber();
-        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(era) {
-        return (era.product.div(this.productSnapshotEntry)).mul(new Decimal__default["default"](this.deposit));
-    }
-    getSolAvailable(era) {
-        return era.sum[0].minus(this.sumSnapshotsEntry[0]).div(this.productSnapshotEntry).mul(new Decimal__default["default"](this.deposit)).floor();
-    }
-}
-// 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;
-exports.DecimalFromU128 = DecimalFromU128;
-exports.HEDGE_PROGRAM_ID = HEDGE_PROGRAM_ID;
-exports.HEDGE_PROGRAM_PUBLICKEY = HEDGE_PROGRAM_PUBLICKEY;
-exports.LiquidationPoolEra = LiquidationPoolEra;
-exports.LiquidationPoolState = LiquidationPoolState;
-exports.LiquidationPosition = LiquidationPosition;
-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.getUsdhMintPublicKey = getUsdhMintPublicKey;
-exports.getVaultSystemStatePublicKey = getVaultSystemStatePublicKey;
-exports.liquidateVault = liquidateVault;
-exports.liquidateVaultInstruction = liquidateVaultInstruction;
-exports.loanVault = loanVault;
-exports.loanVaultInstruction = loanVaultInstruction;
-exports.redeemVault = redeemVault;
-exports.redeemVaultInstruction = redeemVaultInstruction;
-exports.refreshOraclePrice = refreshOraclePrice;
-exports.refreshOraclePriceInstruction = refreshOraclePriceInstruction;
-exports.repayVault = repayVault;
-exports.repayVaultInstruction = repayVaultInstruction;
-exports.withdrawStakingPool = withdrawStakingPool;
-exports.withdrawStakingPoolInstruction = withdrawStakingPoolInstruction;
-exports.withdrawVault = withdrawVault;
-exports.withdrawVaultInstruction = withdrawVaultInstruction;
-//# sourceMappingURL=index.js.map
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./instructions/createStakingPool"), exports);
+__exportStar(require("./instructions/depositStakingPool"), exports);
+__exportStar(require("./instructions/withdrawStakingPool"), exports);
+__exportStar(require("./instructions/depositLiquidationPool"), exports);
+__exportStar(require("./instructions/closeLiquidationPoolPosition"), exports);
+__exportStar(require("./instructions/claimLiquidationPoolPosition"), exports);
+__exportStar(require("./instructions/createVault"), exports);
+__exportStar(require("./instructions/depositVault"), exports);
+__exportStar(require("./instructions/withdrawVault"), exports);
+__exportStar(require("./instructions/loanVault"), exports);
+__exportStar(require("./instructions/repayVault"), exports);
+__exportStar(require("./instructions/redeemVault"), exports);
+__exportStar(require("./instructions/liquidateVault"), exports);
+__exportStar(require("./instructions/refreshOraclePrice"), exports);
+__exportStar(require("./instructions/initHedgeFoundation"), exports);
+__exportStar(require("./instructions/setHalted"), exports);
+__exportStar(require("./HedgeDecimal"), exports);
+__exportStar(require("./Constants"), exports);
+__exportStar(require("./state/VaultAccount"), exports);
+__exportStar(require("./state/VaultHistoryEvent"), exports);
+__exportStar(require("./state/StakingPool"), exports);
+__exportStar(require("./state/StakingPoolPosition"), exports);
+__exportStar(require("./state/LiquidationPoolEra"), exports);
+__exportStar(require("./state/LiquidationPoolState"), exports);
+__exportStar(require("./state/LiquidationPosition"), exports);