hedge-web3 0.1.27 → 0.1.31

package/lib/state/LiquidationPoolEra.js

@@ -11,7 +11,9 @@ class LiquidationPoolEra {
         this.liquidyPoolEra = liquidyPoolEra;
         this.totalDeposits = liquidyPoolEra.totalDeposits.toNumber();
         this.product = (0, HedgeDecimal_1.DecimalFromU128)(liquidyPoolEra.productBytes);
-        this.sum = liquidyPoolEra.sumBytes.map((sumBytes) => { return (0, HedgeDecimal_1.DecimalFromU128)(sumBytes); });
+        this.sum = liquidyPoolEra.sumBytes.map((sumBytes) => {
+            return (0, HedgeDecimal_1.DecimalFromU128)(sumBytes);
+        });
         this.hedgeRewardsAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(liquidyPoolEra.hedgeRewardsAccumulatorBytes);
         this.hedgeRewardsTimestamp = liquidyPoolEra.hedgeRewardsTimestamp.toNumber();
     }

package/lib/state/LiquidationPosition.js

@@ -31,10 +31,3 @@ class LiquidationPosition {
     }
 }
 exports.LiquidationPosition = LiquidationPosition;
-// 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
-// }

package/lib/state/StakingPool.js

@@ -7,16 +7,15 @@ class StakingPool {
         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 = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.hedgeRewardAccumulator);
         this.ushFeeAccumulator = (0, HedgeDecimal_1.DecimalFromU128)(poolInfo.ushFeeAccumulator);
-        this.collateralFeeAccumulator = poolInfo.collateralFeeAccumulator.map((sum) => { return (0, HedgeDecimal_1.DecimalFromU128)(sum); });
-        // this.currentRewardsPerDay = DecimalFromU128(poolInfo.currentRewardsPerDay)
+        this.collateralFeeAccumulator = poolInfo.collateralFeeAccumulator.map((sum) => {
+            return (0, HedgeDecimal_1.DecimalFromU128)(sum);
+        });
     }
 }
 exports.StakingPool = StakingPool;

package/lib/state/VaultAccount.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VaultAccount = void 0;
 const web3_js_1 = require("@solana/web3.js");
+const decimal_js_1 = __importDefault(require("decimal.js"));
 const HedgeDecimal_1 = require("../HedgeDecimal");
 /**
  * A class that represents an on-chian vault.
@@ -10,6 +14,7 @@ class VaultAccount {
     constructor(vault, publicKey) {
         this.publicKey = publicKey;
         this.vaultOwner = vault.vaultOwner;
+        this.vaultNumber = vault.vaultNumber.toNumber();
         this.pdaSalt = vault.pdaSalt;
         this.deposited = vault.deposited.toNumber();
         this.denormalizedDebt = vault.denormalizedDebt.toNumber();
@@ -49,7 +54,52 @@ class VaultAccount {
      * @returns example: `1b6ca...azy71s`
      */
     toDisplayString() {
-        return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey.toString().substring(this.publicKey.toString().length - 6)}`;
+        return `${this.publicKey.toString().substring(0, 6)}...${this.publicKey
+            .toString()
+            .substring(this.publicKey.toString().length - 6)}`;
+    }
+    addDebt(newNormalizedDebt, vaultTypeCompoundedInterest) {
+        const denormalizedNewDebt = newNormalizedDebt.div(vaultTypeCompoundedInterest);
+        this.denormalizedDebt += denormalizedNewDebt.toNumber();
+    }
+    addDeposit(depositAmount) {
+        this.deposited += depositAmount;
+    }
+    redeem() {
+        // TODO - Calculate actual redeem amount and adust correctly
+        this.denormalizedDebt = 0;
+        this.vaultStatus = 'initialized';
+    }
+    liquidate() {
+        // TODO - Calculate actual liquidate amount and adust correctly
+        this.denormalizedDebt = 0;
+        this.vaultStatus = 'liquidated';
+    }
+    updateDebtAndCollateral(vaultTypeAccuntData) {
+        const debtProductCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.debtRedistributionProduct);
+        const collateralAccumulatorCurrent = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccuntData.collateralRedistributionAccumulator);
+        this.denormalizedDebt = debtProductCurrent
+            .div(this.debtProductSnapshotBytes)
+            .mul(new decimal_js_1.default(this.denormalizedDebt))
+            // .add(new Decimal(vaultTypeAccuntData.debtRedistributionError))
+            .toNumber();
+        const extraCollateralDeposited = this.denormalizedDebt * collateralAccumulatorCurrent.sub(this.collateralAccumulatorSnapshotBytes).toNumber();
+        this.deposited += extraCollateralDeposited;
+        this.collateralAccumulatorSnapshotBytes = collateralAccumulatorCurrent;
+        this.debtProductSnapshotBytes = debtProductCurrent;
+    }
+    toString(highlight) {
+        let arrow = '';
+        if (this.publicKey.toString() === highlight.toString()) {
+            arrow = ' <----';
+        }
+        let collateralRatio = 'Infinite';
+        if (this.denormalizedDebt > 0) {
+            collateralRatio = (this.deposited / this.denormalizedDebt).toFixed(8);
+        }
+        return `Vault(${this.vaultNumber}): ${this.publicKey
+            .toString()
+            .substring(0, 6)}. Debt: ${this.inUsd()} Collat: ${collateralRatio} ${arrow}`;
     }
 }
 exports.VaultAccount = VaultAccount;

package/lib/utils/getLinkedListAccounts.js

@@ -0,0 +1,139 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLinkedListAccounts = void 0;
+const underscore_1 = __importDefault(require("underscore"));
+const HedgeDecimal_1 = require("../HedgeDecimal");
+const VaultAccount_1 = require("../state/VaultAccount");
+const decimal_js_1 = __importDefault(require("decimal.js"));
+function getLinkedListAccounts(program, provider, vaultTypeAccountPublicKey, vaultPublicKey, depositAmount, loanAmount, redeem, liquidate, cachedVaults) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const vaultTypeAccount = yield program.account.vaultType.fetch(vaultTypeAccountPublicKey);
+        // Default for null is the vault itself, so set them all to this vault
+        let oldSmallerPublicKey = vaultPublicKey;
+        let newSmallerPublicKey = vaultPublicKey;
+        let newLargerPublicKey = vaultPublicKey;
+        const thisVaultData = yield program.account.vault.fetch(vaultPublicKey);
+        const thisVault = new VaultAccount_1.VaultAccount(thisVaultData, vaultPublicKey);
+        // Load all the vaults
+        let vaults;
+        if (cachedVaults) {
+            vaults = cachedVaults;
+        }
+        else {
+            let allVaults = cachedVaults
+                ? cachedVaults
+                : (yield program.account.vault
+                    .all([
+                // {
+                //   memcmp: { bytes: bs58.encode(inputCollateralType), offset: 8 + 32 + 8 },
+                // },
+                ])
+                    .catch((error) => {
+                    console.log('error', error);
+                })) || [];
+            // Load them into our account objects
+            vaults = allVaults.map((vault) => {
+                return new VaultAccount_1.VaultAccount(vault.account, vault.publicKey);
+            });
+        }
+        // Filter out the account that are not the same vault type
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.collateralType === vaultTypeAccount.collateralType;
+        });
+        // Filter out the accounts that are not open
+        vaults = underscore_1.default.filter(vaults, (vault) => {
+            return vault.vaultStatus === 'open';
+        });
+        // Sort them
+        vaults.sort(sortVaults);
+        // Find the location of the vault before the operation
+        let indexBefore = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexBefore = index;
+            }
+        });
+        // If we found it before, set the old smaller vault the one to the left
+        if (indexBefore > 0) {
+            oldSmallerPublicKey = vaults[indexBefore - 1].publicKey;
+        }
+        // Pretty print all the vaults before the operation
+        // console.log('Sorted open vaults before')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // If it wasn't in the list, add it now
+        if (indexBefore < 0) {
+            vaults.push(thisVault);
+            indexBefore = vaults.length - 1;
+        }
+        // Now that we know it's def in the list, iterate the list and update
+        // this vault with the opeation we're going to apply
+        const newNormalizedDebt = new decimal_js_1.default(loanAmount);
+        const vaultTypeCompoundedInterest = (0, HedgeDecimal_1.DecimalFromU128)(vaultTypeAccount.cumulativeRate.toString());
+        vaults[indexBefore].updateDebtAndCollateral(vaultTypeAccount);
+        vaults[indexBefore].addDebt(newNormalizedDebt, vaultTypeCompoundedInterest);
+        vaults[indexBefore].addDeposit(depositAmount);
+        if (liquidate) {
+            vaults[indexBefore].liquidate();
+        }
+        if (redeem) {
+            vaults[indexBefore].redeem();
+        }
+        if (vaults[indexBefore].denormalizedDebt === 0) {
+            vaults.splice(indexBefore, 1);
+        }
+        // Sort it again since we've changed one vault
+        vaults = vaults.sort(sortVaults);
+        // Pretty print the list again
+        // console.log('Sorted open vaults with new debt added')
+        // vaults.forEach((vault) => {
+        //   console.log(vault.toString(vaultPublicKey))
+        // })
+        // Search for the vaults new position
+        let indexAfter = -1;
+        vaults.forEach((vault, index) => {
+            if (vault.publicKey.toString() === vaultPublicKey.toString()) {
+                indexAfter = index;
+            }
+        });
+        // Print where it moved from / to
+        // console.log('Index Before', indexBefore)
+        // console.log('Index After', indexAfter)
+        // Save references to the new left and right
+        if (indexAfter > 0) {
+            newSmallerPublicKey = vaults[indexAfter - 1].publicKey;
+        }
+        if (indexAfter < vaults.length - 1 && indexAfter >= 0) {
+            newLargerPublicKey = vaults[indexAfter + 1].publicKey;
+        }
+        // Print out the new left/right
+        // console.log('oldSmallerPublicKey', oldSmallerPublicKey.toString())
+        // console.log('newSmallerPublicKey', newSmallerPublicKey.toString())
+        // console.log('newLargerPublicKey', newLargerPublicKey.toString())
+        return [oldSmallerPublicKey, newSmallerPublicKey, newLargerPublicKey, vaults];
+    });
+}
+exports.getLinkedListAccounts = getLinkedListAccounts;
+// Sort function we can use to sort the vaults
+// Sorted by collateral ratio. If two are the same, newer vault first
+function sortVaults(a, b) {
+    const aRatio = a.deposited / a.denormalizedDebt;
+    const bRatio = b.deposited / b.denormalizedDebt;
+    if (aRatio === bRatio) {
+        return b.vaultNumber - a.vaultNumber;
+    }
+    return aRatio - bRatio;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hedge-web3",
-  "version": "0.1.27",
+  "version": "0.1.31",
   "description": "Hedge Javascript Web3 API",
   "main": "lib/index.js",
   "types": "declarations/index.d.ts",
@@ -14,13 +14,14 @@
   "author": "Chris Coudron <coudron@hedge.so>",
   "license": "ISC",
   "dependencies": {
-    "@project-serum/anchor": "^0.23.0",
+    "@project-serum/anchor": "^0.24.1",
     "@project-serum/serum": "^0.13.61",
     "@rollup/plugin-typescript": "^8.3.0",
     "@solana/buffer-layout": "^4.0.0",
     "@solana/spl-token": "^0.2.0",
     "@solana/web3.js": "^1.37.0",
     "@types/bn.js": "^5.1.0",
+    "@types/underscore": "^1.11.4",
     "@types/uuid": "^8.3.4",
     "bn.js": "^5.2.0",
     "decimal.js": "^10.3.1",
@@ -28,6 +29,7 @@
     "ts-standard": "^11.0.0",
     "typedoc": "^0.22.10",
     "typescript": "^4.5.5",
+    "underscore": "^1.13.2",
     "uuid": "^8.3.2"
   }
 }

package/src/Constants.ts

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