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

package/dist/index.cjs

@@ -15629,20 +15629,12 @@ function makeEndFlashLoanIx(mfiProgram, accounts, remainingAccounts = []) {
   }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
 }
 async function makeAccountTransferToNewAccountIx(mfProgram, accounts) {
-  const {
-    oldMarginfiAccount,
-    newMarginfiAccount,
-    newAuthority,
-    globalFeeWallet,
-    feePayer,
-    ...optionalAccounts
-  } = accounts;
+  const { oldMarginfiAccount, newMarginfiAccount, newAuthority, feePayer, ...optionalAccounts } = accounts;
   return mfProgram.methods.transferToNewAccount().accounts({
     oldMarginfiAccount,
     newMarginfiAccount,
     newAuthority,
-    globalFeeWallet,
-    feePayer
+    globalFeeWallet: feePayer
   }).accountsPartial(optionalAccounts).instruction();
 }
 async function makeGroupInitIx(mfProgram, accounts) {
@@ -20536,77 +20528,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 activeLiabilitiesSet = new Set(activeLiabilities.map((b) => b.toBase58()));
-  const activeCollateralSet = 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,
-    activeLiabilitiesSet,
-    activeCollateralSet
-  );
-  const baseOn = basePairs.length > 0;
   const existingTags = new Set(
-    Array.from(activeLiabilitiesSet).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;
@@ -20623,26 +20554,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(activeLiabilitiesSet), C = new Set(activeCollateralSet);
+  function simulate(bank, action) {
+    bank.equals(new web3_js.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) {
@@ -20678,29 +20610,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 (!activeCollateralSet.has(key)) {
-      impact.borrowImpact = simulate(key, "borrow");
+    if (!activeCollateral.some((x) => x.equals(bank))) {
+      impact.borrowImpact = simulate(bank, "borrow");
     }
-    if (allCollateralBankStrs.has(key) && !activeCollateralSet.has(key) && !activeLiabilitiesSet.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 (activeLiabilitiesSet.has(key)) {
-      impact.repayAllImpact = simulate(key, "repay");
+    if (activeLiabilities.some((x) => x.equals(bank))) {
+      impact.repayAllImpact = simulate(bank, "repay");
     }
-    if (activeCollateralSet.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 {
@@ -36119,48 +36088,6 @@ async function makeCloseMarginfiAccountTx({
   );
   return closeTx;
 }
-async function makeAccountTransferToNewAccountTx({
-  connection,
-  program,
-  marginfiAccount,
-  newMarginfiAccount,
-  newAuthority,
-  feePayer,
-  feePayerKeypair
-}) {
-  const [feeStateKey] = web3_js.PublicKey.findProgramAddressSync(
-    [Buffer.from("feestate", "utf-8")],
-    program.programId
-  );
-  const feeState = await program.account.feeState.fetch(feeStateKey);
-  const transferIx = await instructions_default.makeAccountTransferToNewAccountIx(program, {
-    oldMarginfiAccount: marginfiAccount.address,
-    newMarginfiAccount: newMarginfiAccount.publicKey,
-    newAuthority,
-    globalFeeWallet: feeState.globalFeeWallet,
-    feePayer
-  });
-  const {
-    value: { blockhash }
-  } = await connection.getLatestBlockhashAndContext("confirmed");
-  const signers = [newMarginfiAccount];
-  if (feePayerKeypair) signers.push(feePayerKeypair);
-  const transferTx = addTransactionMetadata(
-    new web3_js.VersionedTransaction(
-      new web3_js.TransactionMessage({
-        instructions: [transferIx],
-        payerKey: feePayer,
-        recentBlockhash: blockhash
-      }).compileToV0Message([])
-    ),
-    {
-      signers,
-      addressLookupTables: [],
-      type: "TRANSFER_AUTH" /* TRANSFER_AUTH */
-    }
-  );
-  return transferTx;
-}
 async function makeCreateAccountTxWithProjection(props) {
   const [marginfiAccountAddress] = deriveMarginfiAccount(
     props.program.programId,
@@ -54151,15 +54078,14 @@ var MarginfiAccount = class _MarginfiAccount {
    *
    * @see {@link makeAccountTransferToNewAccountIx} for implementation
    */
-  async makeAccountTransferToNewAccountIx(program, newMarginfiAccount, newAuthority, globalFeeWallet, feePayer) {
+  async makeAccountTransferToNewAccountIx(program, newMarginfiAccount, newAuthority) {
     const accountTransferToNewAccountIx = await instructions_default.makeAccountTransferToNewAccountIx(
       program,
       {
         oldMarginfiAccount: this.address,
         newMarginfiAccount,
         newAuthority,
-        globalFeeWallet,
-        feePayer
+        feePayer: this.authority
       }
     );
     return { instructions: [accountTransferToNewAccountIx], keys: [] };
@@ -54815,13 +54741,11 @@ var MarginfiAccountWrapper = class {
    * @param newMarginfiAccount - New account public key
    * @param newAuthority - New authority public key
    */
-  async makeAccountTransferToNewAccountIx(newMarginfiAccount, newAuthority, globalFeeWallet, feePayer) {
+  async makeAccountTransferToNewAccountIx(newMarginfiAccount, newAuthority) {
     return this.account.makeAccountTransferToNewAccountIx(
       this.client.program,
       newMarginfiAccount,
-      newAuthority,
-      globalFeeWallet,
-      feePayer
+      newAuthority
     );
   }
   /**
@@ -55888,7 +55812,6 @@ exports.isFlashloan = isFlashloan;
 exports.isV0Tx = isV0Tx;
 exports.isWeightedPrice = isWeightedPrice;
 exports.isWholePosition = isWholePosition;
-exports.makeAccountTransferToNewAccountTx = makeAccountTransferToNewAccountTx;
 exports.makeAddPermissionlessStakedBankIx = makeAddPermissionlessStakedBankIx;
 exports.makeBeginFlashLoanIx = makeBeginFlashLoanIx3;
 exports.makeBorrowIx = makeBorrowIx3;