@0dotxyz/p0-ts-sdk 2.2.3-alpha.0 → 2.2.3

package/dist/index.js

@@ -20501,72 +20501,16 @@ function createActiveEmodePairFromPairs(pairs) {
     assetWeightInit: bestPair.assetWeightInit
   };
 }
-function indexConfiguredPairs(emodePairs) {
-  const configured = [];
-  const liabTagByBank = /* @__PURE__ */ new Map();
-  for (const p of emodePairs) {
-    if (p.collateralBankTag === 0 /* UNSET */ || p.liabilityBankTag === 0 /* UNSET */) {
-      continue;
-    }
-    const liabStr = p.liabilityBank.toBase58();
-    const liabTagStr = p.liabilityBankTag.toString();
-    configured.push({
-      orig: p,
-      liabStr,
-      liabTagStr,
-      collTagStr: p.collateralBankTag.toString(),
-      collStrs: p.collateralBanks.map((b) => b.toBase58())
-    });
-    liabTagByBank.set(liabStr, liabTagStr);
-  }
-  return { configured, liabTagByBank };
-}
-function activePairsFromIndex(configured, liabTagByBank, liabSet, collSet) {
-  const requiredTags = /* @__PURE__ */ new Set();
-  for (const liab of liabSet) {
-    const tag = liabTagByBank.get(liab);
-    if (!tag) return [];
-    requiredTags.add(tag);
-  }
-  const possible = configured.filter(
-    (p) => liabSet.has(p.liabStr) && p.collStrs.some((c) => collSet.has(c))
-  );
-  if (possible.length === 0) return [];
-  const byCollTag = {};
-  for (const p of possible) {
-    (byCollTag[p.collTagStr] ||= []).push(p);
-  }
-  const validGroups = [];
-  for (const group of Object.values(byCollTag)) {
-    const supports = new Set(group.map((p) => p.liabTagStr));
-    let coversAll = true;
-    for (const rt of requiredTags) {
-      if (!supports.has(rt)) {
-        coversAll = false;
-        break;
-      }
-    }
-    if (coversAll) validGroups.push(group);
-  }
-  if (validGroups.length === 0) return [];
-  return validGroups.flat().map((p) => p.orig);
-}
 function computeEmodeImpacts(emodePairs, activeLiabilities, activeCollateral, allBanks) {
-  const liabBaseSet = new Set(activeLiabilities.map((b) => b.toBase58()));
-  const collBaseSet = new Set(activeCollateral.map((b) => b.toBase58()));
-  const { configured, liabTagByBank } = indexConfiguredPairs(emodePairs);
-  const liabTagMapAll = /* @__PURE__ */ new Map();
-  for (const p of emodePairs) {
-    liabTagMapAll.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
-  }
-  const allCollateralBankStrs = /* @__PURE__ */ new Set();
+  const toKey = (k) => k.toBase58();
+  const basePairs = computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral);
+  const baseOn = basePairs.length > 0;
+  const liabTagMap = /* @__PURE__ */ new Map();
   for (const p of emodePairs) {
-    for (const c of p.collateralBanks) allCollateralBankStrs.add(c.toBase58());
+    liabTagMap.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
   }
-  const basePairs = activePairsFromIndex(configured, liabTagByBank, liabBaseSet, collBaseSet);
-  const baseOn = basePairs.length > 0;
   const existingTags = new Set(
-    Array.from(liabBaseSet).map((l) => liabTagMapAll.get(l)).filter((t) => !!t)
+    activeLiabilities.map((l) => liabTagMap.get(l.toBase58())).filter((t) => !!t)
   );
   function minWeight(ps) {
     let m = ps[0].assetWeightInit;
@@ -20583,26 +20527,27 @@ function computeEmodeImpacts(emodePairs, activeLiabilities, activeCollateral, al
     if (aMin.lt(bMin)) return 3 /* ReduceEmode */;
     return 1 /* ExtendEmode */;
   }
-  function simulate(bankStr, action) {
-    const L = new Set(liabBaseSet), C = new Set(collBaseSet);
+  function simulate(bank, action) {
+    bank.equals(new PublicKey("CCKtUs6Cgwo4aaQUmBPmyoApH2gUDErxNZCAntD6LYGh"));
+    let L = [...activeLiabilities], C = [...activeCollateral];
     switch (action) {
       case "borrow":
-        L.add(bankStr);
+        if (!L.some((x) => x.equals(bank))) L.push(bank);
         break;
       case "repay":
-        L.delete(bankStr);
+        L = L.filter((x) => !x.equals(bank));
         break;
       case "supply":
-        C.add(bankStr);
+        if (!C.some((x) => x.equals(bank))) C.push(bank);
         break;
       case "withdraw":
-        C.delete(bankStr);
+        C = C.filter((x) => !x.equals(bank));
         break;
     }
-    const after = activePairsFromIndex(configured, liabTagByBank, L, C);
+    const after = computeActiveEmodePairs(emodePairs, L, C);
     let status = diffState(basePairs, after);
     if (action === "borrow") {
-      const tag = liabTagMapAll.get(bankStr);
+      const tag = liabTagMap.get(bank.toBase58());
       if (!tag) {
         status = baseOn ? 4 /* RemoveEmode */ : 5 /* InactiveEmode */;
       } else if (baseOn) {
@@ -20638,29 +20583,66 @@ function computeEmodeImpacts(emodePairs, activeLiabilities, activeCollateral, al
   }
   const result = {};
   for (const bank of allBanks) {
-    const key = bank.toBase58();
+    const key = toKey(bank);
     const impact = {};
-    if (!collBaseSet.has(key)) {
-      impact.borrowImpact = simulate(key, "borrow");
+    if (!activeCollateral.some((x) => x.equals(bank))) {
+      impact.borrowImpact = simulate(bank, "borrow");
     }
-    if (allCollateralBankStrs.has(key) && !collBaseSet.has(key) && !liabBaseSet.has(key)) {
-      impact.supplyImpact = simulate(key, "supply");
+    const collSet = new Set(emodePairs.flatMap((p) => p.collateralBanks.map((c) => c.toBase58())));
+    if (collSet.has(key) && !activeCollateral.some((x) => x.equals(bank)) && !activeLiabilities.some((x) => x.equals(bank))) {
+      impact.supplyImpact = simulate(bank, "supply");
     }
-    if (liabBaseSet.has(key)) {
-      impact.repayAllImpact = simulate(key, "repay");
+    if (activeLiabilities.some((x) => x.equals(bank))) {
+      impact.repayAllImpact = simulate(bank, "repay");
     }
-    if (collBaseSet.has(key)) {
-      impact.withdrawAllImpact = simulate(key, "withdraw");
+    if (activeCollateral.some((x) => x.equals(bank))) {
+      impact.withdrawAllImpact = simulate(bank, "withdraw");
     }
     result[key] = impact;
   }
   return result;
 }
 function computeActiveEmodePairs(emodePairs, activeLiabilities, activeCollateral) {
-  const { configured, liabTagByBank } = indexConfiguredPairs(emodePairs);
-  const liabSet = new Set(activeLiabilities.map((b) => b.toBase58()));
-  const collSet = new Set(activeCollateral.map((b) => b.toBase58()));
-  return activePairsFromIndex(configured, liabTagByBank, liabSet, collSet);
+  const configured = emodePairs.filter(
+    (p) => p.collateralBankTag !== 0 /* UNSET */ && p.liabilityBankTag !== 0 /* UNSET */
+  );
+  const liabTagByBank = /* @__PURE__ */ new Map();
+  for (const p of configured) {
+    liabTagByBank.set(p.liabilityBank.toBase58(), p.liabilityBankTag.toString());
+  }
+  const requiredTags = /* @__PURE__ */ new Set();
+  for (const liab of activeLiabilities) {
+    const tag = liabTagByBank.get(liab.toBase58());
+    if (!tag) {
+      return [];
+    }
+    requiredTags.add(tag);
+  }
+  const possible = configured.filter(
+    (p) => activeLiabilities.some((l) => l.equals(p.liabilityBank)) && p.collateralBanks.some((c) => activeCollateral.some((a) => a.equals(c)))
+  );
+  if (possible.length === 0) return [];
+  const byCollTag = {};
+  for (const p of possible) {
+    const ct = p.collateralBankTag.toString();
+    (byCollTag[ct] ||= []).push(p);
+  }
+  const validGroups = [];
+  for (const group of Object.values(byCollTag)) {
+    const supports = new Set(group.map((p) => p.liabilityBankTag.toString()));
+    let coversAll = true;
+    for (const rt of requiredTags) {
+      if (!supports.has(rt)) {
+        coversAll = false;
+        break;
+      }
+    }
+    if (coversAll) {
+      validGroups.push(group);
+    }
+  }
+  if (validGroups.length === 0) return [];
+  return validGroups.flat();
 }
 function computeBalanceUsdValue(params) {
   const {