hedge-web3 0.1.1 → 0.1.6

package/lib/index.js

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