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

package/dist/index.cjs

@@ -69954,26 +69954,9 @@ var CU_IXS = () => [
   web3_js.ComputeBudgetProgram.setComputeUnitLimit({ units: 14e5 }),
   web3_js.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: 1 })
 ];
-function requireBank(bankMap, address) {
-  const bank = bankMap.get(address.toBase58());
-  if (!bank) {
-    throw TransactionBuildingError.transferPositionsInvalidSelection(
-      `bank ${address.toBase58()} not found`,
-      [address.toBase58()]
-    );
-  }
-  return bank;
-}
-function requireTokenProgram(tokenProgramsByBank, address) {
-  const tp = tokenProgramsByBank.get(address.toBase58());
-  if (!tp) {
-    throw TransactionBuildingError.transferPositionsInvalidSelection(
-      `token program for bank ${address.toBase58()} not provided`,
-      [address.toBase58()]
-    );
-  }
-  return tp;
-}
+var invalidSelection = (address) => (message) => TransactionBuildingError.transferPositionsInvalidSelection(message, [
+  address.toBase58()
+]);
 function classifyAndValidate(params) {
   const {
     marginfiAccount: accountA,
@@ -69996,8 +69979,8 @@ function classifyAndValidate(params) {
   const activeBalancesA = accountA.balances.filter((b) => b.active);
   const positions = [];
   for (const bankAddress of bankAddresses) {
-    const bank = requireBank(bankMap, bankAddress);
-    const tokenProgram = requireTokenProgram(tokenProgramsByBank, bankAddress);
+    const bank = requireBank(bankMap, bankAddress, invalidSelection(bankAddress));
+    const tokenProgram = requireTokenProgram(tokenProgramsByBank, bankAddress, invalidSelection(bankAddress));
     const balance = activeBalancesA.find((b) => b.bankPk.equals(bankAddress));
     if (!balance) {
       throw TransactionBuildingError.transferPositionsInvalidSelection(
@@ -70362,7 +70345,7 @@ async function makeTransferPositionsTx(params) {
   const innerIxs = await buildInnerIxs(ctx, positions, false);
   const transferred = new Set(positions.map((p) => p.bankAddress.toBase58()));
   const projectedActiveBanksA = dedupeBanks(
-    accountA.balances.filter((b) => b.active && !transferred.has(b.bankPk.toBase58())).map((b) => requireBank(bankMap, b.bankPk))
+    accountA.balances.filter((b) => b.active && !transferred.has(b.bankPk.toBase58())).map((b) => requireBank(bankMap, b.bankPk, invalidSelection(b.bankPk)))
   );
   const blockhash = (await connection.getLatestBlockhash("confirmed")).blockhash;
   const preIxs = createIx ? [createIx] : [];
@@ -70410,8 +70393,15 @@ async function makeTransferPositionsTx(params) {
       )
     );
   }
+  const destinationOnlyBalances = accountB.balances.filter(
+    (b) => b.active && !accountA.balances.some((a) => a.active && a.bankPk.equals(b.bankPk))
+  );
+  const crankBalanceView = {
+    ...accountA,
+    balances: [...accountA.balances, ...destinationOnlyBalances]
+  };
   const { instructions: updateFeedIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
-    marginfiAccount: accountA,
+    marginfiAccount: crankBalanceView,
     bankMap,
     oraclePrices,
     assetShareValueMultiplierByBank,
@@ -70440,6 +70430,301 @@ async function makeTransferPositionsTx(params) {
     destinationAccount: accountB
   };
 }
+var BULK_TX_SIZE_MARGIN = 128;
+function computeV0TxSizeSafe(ixs, payer, luts) {
+  try {
+    return computeV0TxSize(ixs, payer, luts);
+  } catch {
+    return { size: Number.MAX_SAFE_INTEGER, accountCount: Number.MAX_SAFE_INTEGER };
+  }
+}
+function fitsInTx(ixs, payer, luts) {
+  const { size, accountCount } = computeV0TxSizeSafe(ixs, payer, luts);
+  return size <= MAX_TX_SIZE - BULK_TX_SIZE_MARGIN && accountCount <= MAX_ACCOUNT_LOCKS;
+}
+function buildTxRefreshIxs(args) {
+  const { marginfiAccount, bankMap, bankMetadataMap, txBanks } = args;
+  const ixs = [];
+  const kaminoPks = txBanks.filter((b) => b.config.assetTag === 3 /* KAMINO */).map((b) => b.address);
+  if (kaminoPks.length > 0) {
+    ixs.push(
+      ...makeRefreshKaminoBanksIxs(marginfiAccount, bankMap, kaminoPks, bankMetadataMap).instructions
+    );
+  }
+  const jupPksInTx = txBanks.filter((b) => b.config.assetTag === 6 /* JUPLEND */).map((b) => b.address);
+  if (jupPksInTx.length > 0) {
+    ixs.push(
+      ...makeUpdateJupLendRateIxs(marginfiAccount, bankMap, jupPksInTx, bankMetadataMap).instructions
+    );
+  }
+  return ixs;
+}
+async function makeBulkWithdrawTx(params) {
+  const {
+    program,
+    connection,
+    marginfiAccount,
+    bankAddresses,
+    bankMap,
+    bankMetadataMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    tokenProgramsByBank,
+    overrideInferAccounts
+  } = params;
+  const luts = params.addressLookupTableAccounts ?? [];
+  const groupRateLimiterEnabled = params.groupRateLimiterEnabled ?? false;
+  const authority = marginfiAccount.authority;
+  if (bankAddresses.length === 0) throw new Error("no banks to withdraw");
+  const activeBalances = marginfiAccount.balances.filter((b) => b.active);
+  const legs = [];
+  const withdrawnSoFar = [];
+  for (const bankAddress of bankAddresses) {
+    const bank = requireBank(bankMap, bankAddress);
+    const tokenProgram = requireTokenProgram(tokenProgramsByBank, bankAddress);
+    const balance = activeBalances.find((b) => b.bankPk.equals(bankAddress));
+    if (!balance || !balance.assetShares.gt(0)) {
+      throw new Error(`no active deposit for bank ${bankAddress.toBase58()}`);
+    }
+    const multiplier = assetShareValueMultiplierByBank.get(bankAddress.toBase58());
+    const uiAmount = computeQuantityUi(balance, bank, multiplier).assets;
+    const packBanks = computeHealthCheckAccounts(
+      marginfiAccount.balances,
+      bankMap,
+      [],
+      [...withdrawnSoFar, bankAddress]
+    );
+    const observationBanksOverride = computeHealthAccountMetas(packBanks, true, [bank]);
+    const shared = {
+      program,
+      bank,
+      bankMap,
+      tokenProgram,
+      marginfiAccount,
+      authority,
+      bankMetadataMap,
+      withdrawAll: true,
+      opts: {
+        createAtas: false,
+        // ATAs are created in the prelude txs
+        wrapAndUnwrapSol: true,
+        overrideInferAccounts,
+        observationBanksOverride
+      }
+    };
+    let instructions2;
+    switch (bank.config.assetTag) {
+      case 3 /* KAMINO */: {
+        const reserve = bankMetadataMap[bankAddress.toBase58()]?.kaminoStates?.reserveState;
+        if (!reserve) {
+          throw new Error(`kamino reserve state missing for bank ${bankAddress.toBase58()}`);
+        }
+        const withdraw = await makeKaminoWithdrawIx3({
+          ...shared,
+          cTokenAmount: uiAmount.div(multiplier ?? new BigNumber3.BigNumber(1)),
+          reserve
+        });
+        instructions2 = withdraw.instructions;
+        break;
+      }
+      case 6 /* JUPLEND */: {
+        const jupLendingState = bankMetadataMap[bankAddress.toBase58()]?.jupLendStates?.jupLendingState;
+        if (!jupLendingState) {
+          throw new Error(`juplend lending state missing for bank ${bankAddress.toBase58()}`);
+        }
+        const withdraw = await makeJuplendWithdrawIx2({
+          ...shared,
+          amount: uiAmount,
+          jupLendingState
+        });
+        instructions2 = withdraw.instructions;
+        break;
+      }
+      case 4 /* DRIFT */: {
+        const driftState = bankMetadataMap[bankAddress.toBase58()]?.driftStates;
+        if (!driftState) {
+          throw new Error(`drift state missing for bank ${bankAddress.toBase58()}`);
+        }
+        const withdraw = await makeDriftWithdrawIx3({
+          ...shared,
+          amount: uiAmount,
+          driftSpotMarket: driftState.spotMarketState,
+          userRewards: driftState.userRewards
+        });
+        instructions2 = withdraw.instructions;
+        break;
+      }
+      default: {
+        const withdraw = await makeWithdrawIx3({
+          ...shared,
+          amount: uiAmount
+        });
+        instructions2 = withdraw.instructions;
+        break;
+      }
+    }
+    legs.push({ bank, instructions: instructions2 });
+    withdrawnSoFar.push(bankAddress);
+  }
+  const bundles = [];
+  let current = [];
+  const assembleTxIxs = (bundle) => [
+    ...buildTxRefreshIxs({
+      marginfiAccount,
+      bankMap,
+      bankMetadataMap,
+      txBanks: bundle.map((l) => l.bank)
+    }),
+    ...bundle.flatMap((l) => l.instructions)
+  ];
+  for (const leg of legs) {
+    const candidate = [...current, leg];
+    if (current.length > 0 && !fitsInTx(assembleTxIxs(candidate), authority, luts)) {
+      bundles.push(current);
+      current = [leg];
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) bundles.push(current);
+  for (const bundle of bundles) {
+    const ixs = assembleTxIxs(bundle);
+    if (bundle.length === 1 && !fitsInTx(ixs, authority, luts)) {
+      throw new Error(
+        `withdraw for bank ${bundle[0].bank.address.toBase58()} does not fit one transaction`
+      );
+    }
+  }
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const withdrawTxs = bundles.map((bundle) => {
+    const message = new web3_js.TransactionMessage({
+      payerKey: authority,
+      recentBlockhash: blockhash,
+      instructions: assembleTxIxs(bundle)
+    }).compileToV0Message(luts);
+    return addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+      addressLookupTables: luts,
+      type: "WITHDRAW" /* WITHDRAW */
+    });
+  });
+  const additionalTxs = [];
+  const setupIxs = await makeSetupIx({
+    connection,
+    authority,
+    tokens: legs.map((l) => ({
+      mint: l.bank.mint,
+      tokenProgram: requireTokenProgram(tokenProgramsByBank, l.bank.address)
+    }))
+  });
+  if (setupIxs.length > 0) {
+    const setupTxs = splitInstructionsToFitTransactions([], setupIxs, {
+      blockhash,
+      payerKey: authority,
+      luts
+    });
+    additionalTxs.push(
+      ...setupTxs.map(
+        (tx) => addTransactionMetadata(tx, {
+          type: "CREATE_ATA" /* CREATE_ATA */,
+          addressLookupTables: luts
+        })
+      )
+    );
+  }
+  const { instructions: crankIxs, luts: feedLuts } = await makeSmartCrankSwbFeedIx({
+    marginfiAccount,
+    bankMap,
+    oraclePrices,
+    assetShareValueMultiplierByBank,
+    instructions: legs.flatMap((l) => l.instructions),
+    program,
+    connection,
+    crossbarUrl: params.crossbarUrl,
+    groupRateLimiterEnabled
+  });
+  if (crankIxs.length > 0) {
+    const message = new web3_js.TransactionMessage({
+      payerKey: authority,
+      recentBlockhash: blockhash,
+      instructions: crankIxs
+    }).compileToV0Message(feedLuts);
+    additionalTxs.push(
+      addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+        addressLookupTables: feedLuts,
+        type: "CRANK" /* CRANK */
+      })
+    );
+  }
+  return {
+    transactions: [...additionalTxs, ...withdrawTxs],
+    actionTxIndex: additionalTxs.length
+  };
+}
+async function makeBulkRepayTx(params) {
+  const {
+    program,
+    connection,
+    marginfiAccount,
+    bankAddresses,
+    bankMap,
+    tokenProgramsByBank,
+    overrideInferAccounts
+  } = params;
+  const luts = params.addressLookupTableAccounts ?? [];
+  const authority = marginfiAccount.authority;
+  if (bankAddresses.length === 0) throw new Error("no banks to repay");
+  const activeBalances = marginfiAccount.balances.filter((b) => b.active);
+  const legs = [];
+  for (const bankAddress of bankAddresses) {
+    const bank = requireBank(bankMap, bankAddress);
+    const tokenProgram = requireTokenProgram(tokenProgramsByBank, bankAddress);
+    const balance = activeBalances.find((b) => b.bankPk.equals(bankAddress));
+    if (!balance || !balance.liabilityShares.gt(0)) {
+      throw new Error(`no active debt for bank ${bankAddress.toBase58()}`);
+    }
+    const uiAmount = computeQuantityUi(balance, bank).liabilities;
+    const repay = await makeRepayIx3({
+      program,
+      bank,
+      tokenProgram,
+      amount: uiAmount,
+      accountAddress: marginfiAccount.address,
+      authority,
+      repayAll: true,
+      opts: {
+        wrapAndUnwrapSol: true,
+        overrideInferAccounts
+      }
+    });
+    legs.push({ bank, instructions: repay.instructions });
+  }
+  const bundles = [];
+  let current = [];
+  for (const leg of legs) {
+    const candidate = [...current, leg];
+    const candidateIxs = candidate.flatMap((l) => l.instructions);
+    if (current.length > 0 && !fitsInTx(candidateIxs, authority, luts)) {
+      bundles.push(current);
+      current = [leg];
+    } else {
+      current = candidate;
+    }
+  }
+  if (current.length > 0) bundles.push(current);
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const transactions = bundles.map((bundle) => {
+    const message = new web3_js.TransactionMessage({
+      payerKey: authority,
+      recentBlockhash: blockhash,
+      instructions: bundle.flatMap((l) => l.instructions)
+    }).compileToV0Message(luts);
+    return addTransactionMetadata(new web3_js.VersionedTransaction(message), {
+      addressLookupTables: luts,
+      type: "REPAY" /* REPAY */
+    });
+  });
+  return { transactions, actionTxIndex: 0 };
+}
 
 // src/services/account/services/account-simulation.service.ts
 async function simulateAccountHealthCacheWithFallback(params) {
@@ -72852,6 +73137,22 @@ function computeBankMetrics(params) {
   };
 }
 
+// src/services/bank/utils/lookup.utils.ts
+function requireBank(bankMap, address, makeError = (message) => new Error(message)) {
+  const bank = bankMap.get(address.toBase58());
+  if (!bank) {
+    throw makeError(`bank ${address.toBase58()} not found`);
+  }
+  return bank;
+}
+function requireTokenProgram(tokenProgramsByBank, address, makeError = (message) => new Error(message)) {
+  const tokenProgram = tokenProgramsByBank.get(address.toBase58());
+  if (!tokenProgram) {
+    throw makeError(`token program for bank ${address.toBase58()} not provided`);
+  }
+  return tokenProgram;
+}
+
 // src/services/bank/bank.service.ts
 async function freezeBankConfigIx(program, bankAddress, bankConfigOpt) {
   let bankConfigRaw;
@@ -76065,6 +76366,8 @@ exports.makeAddPermissionlessStakedBankIx = makeAddPermissionlessStakedBankIx;
 exports.makeBeginFlashLoanIx = makeBeginFlashLoanIx3;
 exports.makeBorrowIx = makeBorrowIx3;
 exports.makeBorrowTx = makeBorrowTx;
+exports.makeBulkRepayTx = makeBulkRepayTx;
+exports.makeBulkWithdrawTx = makeBulkWithdrawTx;
 exports.makeBundleTipIx = makeBundleTipIx;
 exports.makeCloseMarginfiAccountIx = makeCloseMarginfiAccountIx;
 exports.makeCloseMarginfiAccountTx = makeCloseMarginfiAccountTx;
@@ -76145,6 +76448,8 @@ exports.parseRpcPythPriceData = parseRpcPythPriceData;
 exports.parseSwbOraclePriceData = parseSwbOraclePriceData;
 exports.partitionBanksByCrankability = partitionBanksByCrankability;
 exports.patchDepositAmount = patchDepositAmount;
+exports.requireBank = requireBank;
+exports.requireTokenProgram = requireTokenProgram;
 exports.resolveAmount = resolveAmount;
 exports.resolveBridgeBanks = resolveBridgeBanks;
 exports.runSwapEngine = runSwapEngine;