@0dotxyz/p0-ts-sdk 2.2.0 → 2.2.2

package/dist/instructions.d.ts

@@ -0,0 +1,371 @@
+import * as _solana_web3_js from '@solana/web3.js';
+import { PublicKey, AccountMeta } from '@solana/web3.js';
+import BN from 'bn.js';
+import { M as MarginfiProgram, _ as BankConfigCompactRaw, k as BankConfigOptRaw } from './types-DGWxbPM1.js';
+import '@coral-xyz/anchor';
+import 'bignumber.js';
+import './dto-rate-model.types-AQ40wS-P.js';
+
+declare function makeInitMarginfiAccountIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiGroup: PublicKey;
+    marginfiAccount: PublicKey;
+    authority: PublicKey;
+    feePayer: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeInitMarginfiAccountPdaIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiGroup: PublicKey;
+    marginfiAccount: PublicKey;
+    authority: PublicKey;
+    feePayer: PublicKey;
+}, args: {
+    accountIndex: number;
+    thirdPartyId?: number;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeJuplendDepositIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    signerTokenAccount: PublicKey;
+    lendingAdmin: PublicKey;
+    supplyTokenReservesLiquidity: PublicKey;
+    lendingSupplyPositionOnLiquidity: PublicKey;
+    rateModel: PublicKey;
+    vault: PublicKey;
+    liquidity: PublicKey;
+    liquidityProgram: PublicKey;
+    rewardsRateModel: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+    fTokenMint?: PublicKey;
+    integrationAcc1?: PublicKey;
+    integrationAcc2?: PublicKey;
+    mint?: PublicKey;
+}, args: {
+    amount: BN;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeJuplendWithdrawIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    lendingAdmin: PublicKey;
+    supplyTokenReservesLiquidity: PublicKey;
+    lendingSupplyPositionOnLiquidity: PublicKey;
+    rateModel: PublicKey;
+    vault: PublicKey;
+    claimAccount: PublicKey;
+    liquidity: PublicKey;
+    liquidityProgram: PublicKey;
+    rewardsRateModel: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    mint?: PublicKey;
+    integrationAcc1?: PublicKey;
+    fTokenMint?: PublicKey;
+    integrationAcc2?: PublicKey;
+    integrationAcc3?: PublicKey;
+}, args: {
+    amount: BN;
+    withdrawAll?: boolean | null;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeKaminoDepositIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    signerTokenAccount: PublicKey;
+    lendingMarket: PublicKey;
+    lendingMarketAuthority: PublicKey;
+    reserveLiquiditySupply: PublicKey;
+    reserveCollateralMint: PublicKey;
+    reserveDestinationDepositCollateral: PublicKey;
+    liquidityTokenProgram: PublicKey;
+    obligationFarmUserState: PublicKey | null;
+    reserveFarmState: PublicKey | null;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+    integrationAcc1?: PublicKey;
+    integrationAcc2?: PublicKey;
+    mint?: PublicKey;
+}, args: {
+    amount: BN;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+/**
+ * Create a Drift deposit instruction
+ * Deposits tokens into a Drift spot market through a marginfi bank account
+ *
+ * @param mfProgram - The marginfi program instance
+ * @param accounts - Required and optional accounts for the instruction
+ * @param accounts.marginfiAccount - The marginfi account depositing funds
+ * @param accounts.bank - The marginfi bank account for the asset
+ * @param accounts.signerTokenAccount - The signer's token account (source of funds)
+ * @param accounts.driftState - The Drift program state account
+ * @param accounts.driftSpotMarketVault - The Drift spot market vault receiving tokens
+ * @param accounts.tokenProgram - The SPL token program
+ * @param accounts.driftOracle - (Optional) Oracle account for the asset
+ * @param args - Instruction arguments
+ * @param args.amount - Amount to deposit in native token decimals
+ */
+declare function makeDriftDepositIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    signerTokenAccount: PublicKey;
+    driftState: PublicKey;
+    driftSpotMarketVault: PublicKey;
+    tokenProgram: PublicKey;
+    driftOracle: PublicKey | null;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+    integrationAcc2?: PublicKey;
+    integrationAcc3?: PublicKey;
+    integrationAcc1?: PublicKey;
+    mint?: PublicKey;
+    driftProgram?: PublicKey;
+    systemProgram?: PublicKey;
+}, args: {
+    amount: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeDepositIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    signerTokenAccount: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+    depositUpToLimit?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeRepayIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    signerTokenAccount: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+    liquidityVault?: PublicKey;
+}, args: {
+    amount: BN;
+    repayAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeDriftWithdrawIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    driftState: PublicKey;
+    driftSigner: PublicKey;
+    driftSpotMarketVault: PublicKey;
+    tokenProgram: PublicKey;
+    driftOracle: PublicKey | null;
+    driftRewardOracle: PublicKey | null;
+    driftRewardSpotMarket: PublicKey | null;
+    driftRewardMint: PublicKey | null;
+    driftRewardOracle2: PublicKey | null;
+    driftRewardSpotMarket2: PublicKey | null;
+    driftRewardMint2: PublicKey | null;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    amount: BN;
+    withdrawAll: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeKaminoWithdrawIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    lendingMarket: PublicKey;
+    mint: PublicKey;
+    lendingMarketAuthority: PublicKey;
+    reserveLiquiditySupply: PublicKey;
+    reserveCollateralMint: PublicKey;
+    reserveSourceCollateral: PublicKey;
+    liquidityTokenProgram: PublicKey;
+    obligationFarmUserState: PublicKey | null;
+    reserveFarmState: PublicKey | null;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    amount: BN;
+    isFinalWithdrawal: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeWithdrawIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    amount: BN;
+    withdrawAll?: boolean;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBorrowIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+    destinationTokenAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    amount: BN;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeLendingAccountLiquidateIx(mfiProgram: MarginfiProgram, accounts: {
+    assetBank: PublicKey;
+    liabBank: PublicKey;
+    liquidatorMarginfiAccount: PublicKey;
+    liquidateeMarginfiAccount: PublicKey;
+    tokenProgram: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+}, args: {
+    assetAmount: BN;
+    liquidateeAccounts: number;
+    liquidatorAccounts: number;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeLendingAccountClearEmissionsIx(mfiProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    bank: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePoolConfigureBankIx(mfiProgram: MarginfiProgram, accounts: {
+    bank: PublicKey;
+    group?: PublicKey;
+    admin?: PublicKey;
+}, args: {
+    bankConfigOpt: BankConfigOptRaw;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeBeginFlashLoanIx(mfiProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    authority?: PublicKey;
+    ixsSysvar?: PublicKey;
+}, args: {
+    endIndex: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeEndFlashLoanIx(mfiProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    authority?: PublicKey;
+}, remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeAccountTransferToNewAccountIx(mfProgram: MarginfiProgram, accounts: {
+    oldMarginfiAccount: PublicKey;
+    newMarginfiAccount: PublicKey;
+    newAuthority: PublicKey;
+    feePayer: PublicKey;
+    group?: PublicKey;
+    authority?: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeGroupInitIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiGroup: PublicKey;
+    admin: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+/**
+ * Configure the oracle for a bank
+ * @param mfProgram The marginfi program
+ * @param accounts The accounts required for this instruction
+ * @param args The oracle setup index and feed id
+ * @param remainingAccounts The remaining accounts required for this instruction, should include the feed oracle key
+ */
+declare function makeLendingPoolConfigureBankOracleIx(mfProgram: MarginfiProgram, accounts: {
+    bank: PublicKey;
+    group?: PublicKey;
+    admin?: PublicKey;
+}, args: {
+    /**
+     * The oracle setup index, see {@link serializeOracleSetupToIndex}
+     */
+    setup: number;
+    /**
+     * The oracle feed id
+     */
+    feedId: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction, should include the feed oracle key (non writable & signable)
+ */
+remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+/**
+ * Creates an instruction to add a permissionless staked bank to a lending pool.
+ * @param mfProgram - The marginfi program instance
+ * @param accounts - The accounts required for this instruction
+ * @param remainingAccounts - The remaining accounts required for this instruction, including pythOracle, solPool and bankMint
+ * @param args - Optional arguments for this instruction
+ */
+declare function makePoolAddPermissionlessStakedBankIx(mfProgram: MarginfiProgram, accounts: {
+    stakedSettings: PublicKey;
+    feePayer: PublicKey;
+    bankMint: PublicKey;
+    solPool: PublicKey;
+    stakePool: PublicKey;
+    marginfiGroup?: PublicKey;
+    /**
+     * The token program to use for this instruction, defaults to the SPL token program
+     */
+    tokenProgram?: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction. Should include:
+ * - pythOracle: The pyth oracle key (non writable & non signer)
+ * - solPool: The sol pool key (non writable & non signer)
+ * - bankMint: The bank mint key (non writable & non signer)
+ */
+remainingAccounts: AccountMeta[] | undefined, args: {
+    /**
+     * The seed to use for the bank account. Defaults to 0 (new BN(0)).
+     * If the seed is not specified, the seed is set to 0, and the bank account
+     * will be created at the address {@link findPoolAddress} with the default
+     * bump.
+     */
+    seed?: BN;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePoolAddBankIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiGroup: PublicKey;
+    feePayer: PublicKey;
+    bankMint: PublicKey;
+    bank: PublicKey;
+    tokenProgram: PublicKey;
+    admin?: PublicKey;
+    globalFeeWallet?: PublicKey;
+}, args: {
+    bankConfig: BankConfigCompactRaw;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makeCloseAccountIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+    feePayer: PublicKey;
+    authority?: PublicKey;
+}): Promise<_solana_web3_js.TransactionInstruction>;
+declare function makePulseHealthIx(mfProgram: MarginfiProgram, accounts: {
+    marginfiAccount: PublicKey;
+}, 
+/**
+ * The remaining accounts required for this instruction. Should include:
+ * - For each balance the user has, pass bank and oracle: <bank1, oracle1, bank2, oracle2>
+ */
+remainingAccounts?: AccountMeta[]): Promise<_solana_web3_js.TransactionInstruction>;
+declare const instructions: {
+    makeDepositIx: typeof makeDepositIx;
+    makeJuplendDepositIx: typeof makeJuplendDepositIx;
+    makeDriftDepositIx: typeof makeDriftDepositIx;
+    makeKaminoDepositIx: typeof makeKaminoDepositIx;
+    makeRepayIx: typeof makeRepayIx;
+    makeWithdrawIx: typeof makeWithdrawIx;
+    makeJuplendWithdrawIx: typeof makeJuplendWithdrawIx;
+    makeDriftWithdrawIx: typeof makeDriftWithdrawIx;
+    makeKaminoWithdrawIx: typeof makeKaminoWithdrawIx;
+    makeBorrowIx: typeof makeBorrowIx;
+    makeInitMarginfiAccountIx: typeof makeInitMarginfiAccountIx;
+    makeInitMarginfiAccountPdaIx: typeof makeInitMarginfiAccountPdaIx;
+    makeLendingAccountLiquidateIx: typeof makeLendingAccountLiquidateIx;
+    makeLendingAccountClearEmissionsIx: typeof makeLendingAccountClearEmissionsIx;
+    makePoolAddBankIx: typeof makePoolAddBankIx;
+    makePoolConfigureBankIx: typeof makePoolConfigureBankIx;
+    makeBeginFlashLoanIx: typeof makeBeginFlashLoanIx;
+    makeEndFlashLoanIx: typeof makeEndFlashLoanIx;
+    makeAccountTransferToNewAccountIx: typeof makeAccountTransferToNewAccountIx;
+    makeGroupInitIx: typeof makeGroupInitIx;
+    makeCloseAccountIx: typeof makeCloseAccountIx;
+    makePoolAddPermissionlessStakedBankIx: typeof makePoolAddPermissionlessStakedBankIx;
+    makeLendingPoolConfigureBankOracleIx: typeof makeLendingPoolConfigureBankOracleIx;
+    makePulseHealthIx: typeof makePulseHealthIx;
+};
+
+export { instructions as default };

package/dist/instructions.js

@@ -0,0 +1,338 @@
+import BN from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+
+// src/instructions.ts
+new PublicKey(
+  "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr"
+);
+new PublicKey(
+  "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+);
+var TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+
+// src/instructions.ts
+async function makeInitMarginfiAccountIx(mfProgram, accounts) {
+  return mfProgram.methods.marginfiAccountInitialize().accounts(accounts).instruction();
+}
+async function makeInitMarginfiAccountPdaIx(mfProgram, accounts, args) {
+  return mfProgram.methods.marginfiAccountInitializePda(args.accountIndex, args.thirdPartyId ?? null).accountsPartial({
+    marginfiGroup: accounts.marginfiGroup,
+    marginfiAccount: accounts.marginfiAccount,
+    authority: accounts.authority,
+    feePayer: accounts.feePayer
+  }).instruction();
+}
+async function makeJuplendDepositIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const {
+    marginfiAccount,
+    bank,
+    signerTokenAccount,
+    lendingAdmin,
+    supplyTokenReservesLiquidity,
+    lendingSupplyPositionOnLiquidity,
+    rateModel,
+    vault,
+    liquidity,
+    liquidityProgram,
+    rewardsRateModel,
+    tokenProgram,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.juplendDeposit(args.amount).accounts(accounts).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeJuplendWithdrawIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const {
+    marginfiAccount,
+    bank,
+    destinationTokenAccount,
+    lendingAdmin,
+    supplyTokenReservesLiquidity,
+    lendingSupplyPositionOnLiquidity,
+    rateModel,
+    vault,
+    claimAccount,
+    liquidity,
+    liquidityProgram,
+    rewardsRateModel,
+    tokenProgram,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.juplendWithdraw(args.amount, args.withdrawAll ?? null).accounts(accounts).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeKaminoDepositIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const {
+    marginfiAccount,
+    bank,
+    signerTokenAccount,
+    lendingMarket,
+    lendingMarketAuthority,
+    reserveLiquiditySupply,
+    reserveCollateralMint,
+    reserveDestinationDepositCollateral,
+    liquidityTokenProgram,
+    obligationFarmUserState,
+    reserveFarmState,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.kaminoDeposit(args.amount).accounts(accounts).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeDriftDepositIx(mfProgram, accounts, args) {
+  const {
+    marginfiAccount,
+    bank,
+    signerTokenAccount,
+    driftState,
+    driftSpotMarketVault,
+    tokenProgram,
+    driftOracle,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.driftDeposit(args.amount).accounts({
+    marginfiAccount,
+    bank,
+    signerTokenAccount,
+    driftState,
+    driftSpotMarketVault,
+    tokenProgram,
+    driftOracle
+  }).accountsPartial(optionalAccounts).instruction();
+}
+async function makeDepositIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { marginfiAccount, signerTokenAccount, bank, tokenProgram, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingAccountDeposit(args.amount, args.depositUpToLimit ?? null).accounts({
+    marginfiAccount,
+    signerTokenAccount,
+    bank,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeRepayIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { marginfiAccount, signerTokenAccount, bank, tokenProgram, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingAccountRepay(args.amount, args.repayAll ?? null).accounts({
+    marginfiAccount,
+    signerTokenAccount,
+    bank,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeDriftWithdrawIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const {
+    marginfiAccount,
+    bank,
+    destinationTokenAccount,
+    driftState,
+    driftSigner,
+    driftSpotMarketVault,
+    tokenProgram,
+    driftOracle,
+    driftRewardOracle,
+    driftRewardSpotMarket,
+    driftRewardMint,
+    driftRewardOracle2,
+    driftRewardSpotMarket2,
+    driftRewardMint2,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.driftWithdraw(args.amount, args.withdrawAll).accounts({
+    marginfiAccount,
+    bank,
+    destinationTokenAccount,
+    driftState,
+    driftSigner,
+    driftSpotMarketVault,
+    tokenProgram,
+    driftOracle,
+    driftRewardOracle,
+    driftRewardSpotMarket,
+    driftRewardMint,
+    driftRewardOracle2,
+    driftRewardSpotMarket2,
+    driftRewardMint2
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeKaminoWithdrawIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const {
+    marginfiAccount,
+    bank,
+    destinationTokenAccount,
+    lendingMarket,
+    lendingMarketAuthority,
+    reserveLiquiditySupply,
+    reserveCollateralMint,
+    reserveSourceCollateral,
+    liquidityTokenProgram,
+    obligationFarmUserState,
+    reserveFarmState,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.kaminoWithdraw(args.amount, args.isFinalWithdrawal).accounts({
+    marginfiAccount,
+    bank,
+    destinationTokenAccount,
+    lendingMarket,
+    lendingMarketAuthority,
+    reserveLiquiditySupply,
+    reserveCollateralMint,
+    reserveSourceCollateral,
+    liquidityTokenProgram,
+    obligationFarmUserState,
+    reserveFarmState
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeWithdrawIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { marginfiAccount, bank, destinationTokenAccount, tokenProgram, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingAccountWithdraw(args.amount, args.withdrawAll ?? null).accounts({
+    marginfiAccount,
+    destinationTokenAccount,
+    bank,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeBorrowIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { marginfiAccount, bank, destinationTokenAccount, tokenProgram, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingAccountBorrow(args.amount).accounts({
+    marginfiAccount,
+    destinationTokenAccount,
+    bank,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+function makeLendingAccountLiquidateIx(mfiProgram, accounts, args, remainingAccounts = []) {
+  const {
+    assetBank,
+    liabBank,
+    liquidatorMarginfiAccount,
+    liquidateeMarginfiAccount,
+    tokenProgram,
+    ...optionalAccounts
+  } = accounts;
+  return mfiProgram.methods.lendingAccountLiquidate(args.assetAmount, args.liquidateeAccounts, args.liquidatorAccounts).accounts({
+    assetBank,
+    liabBank,
+    liquidatorMarginfiAccount,
+    liquidateeMarginfiAccount,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+function makeLendingAccountClearEmissionsIx(mfiProgram, accounts) {
+  return mfiProgram.methods.lendingAccountClearEmissions().accounts({
+    marginfiAccount: accounts.marginfiAccount,
+    bank: accounts.bank
+  }).instruction();
+}
+function makePoolConfigureBankIx(mfiProgram, accounts, args) {
+  const { bank, ...optionalAccounts } = accounts;
+  return mfiProgram.methods.lendingPoolConfigureBank(args.bankConfigOpt).accounts({
+    bank
+  }).accountsPartial(optionalAccounts).instruction();
+}
+function makeBeginFlashLoanIx(mfiProgram, accounts, args) {
+  const { marginfiAccount, ...optionalAccounts } = accounts;
+  return mfiProgram.methods.lendingAccountStartFlashloan(args.endIndex).accounts({
+    marginfiAccount
+  }).accountsPartial(optionalAccounts).instruction();
+}
+function makeEndFlashLoanIx(mfiProgram, accounts, remainingAccounts = []) {
+  const { marginfiAccount, ...optionalAccounts } = accounts;
+  return mfiProgram.methods.lendingAccountEndFlashloan().accounts({
+    marginfiAccount
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makeAccountTransferToNewAccountIx(mfProgram, accounts) {
+  const { oldMarginfiAccount, newMarginfiAccount, newAuthority, feePayer, ...optionalAccounts } = accounts;
+  return mfProgram.methods.transferToNewAccount().accounts({
+    oldMarginfiAccount,
+    newMarginfiAccount,
+    newAuthority,
+    globalFeeWallet: feePayer
+  }).accountsPartial(optionalAccounts).instruction();
+}
+async function makeGroupInitIx(mfProgram, accounts) {
+  return mfProgram.methods.marginfiGroupInitialize().accounts({
+    marginfiGroup: accounts.marginfiGroup,
+    admin: accounts.admin
+  }).instruction();
+}
+async function makeLendingPoolConfigureBankOracleIx(mfProgram, accounts, args, remainingAccounts = []) {
+  const { bank, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingPoolConfigureBankOracle(args.setup, args.feedId).accounts({
+    bank
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makePoolAddPermissionlessStakedBankIx(mfProgram, accounts, remainingAccounts = [], args) {
+  const {
+    stakedSettings,
+    feePayer,
+    bankMint,
+    solPool,
+    stakePool,
+    tokenProgram = TOKEN_PROGRAM_ID,
+    ...optionalAccounts
+  } = accounts;
+  return mfProgram.methods.lendingPoolAddBankPermissionless(args.seed ?? new BN(0)).accounts({
+    stakedSettings,
+    feePayer,
+    bankMint,
+    solPool,
+    stakePool,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).remainingAccounts(remainingAccounts).instruction();
+}
+async function makePoolAddBankIx(mfProgram, accounts, args) {
+  const { marginfiGroup, feePayer, bankMint, bank, tokenProgram, ...optionalAccounts } = accounts;
+  return mfProgram.methods.lendingPoolAddBank({
+    ...args.bankConfig,
+    configFlags: 0,
+    pad0: [0, 0, 0, 0, 0, 0, 0, 0]
+  }).accounts({
+    marginfiGroup,
+    feePayer,
+    bankMint,
+    bank,
+    tokenProgram
+  }).accountsPartial(optionalAccounts).instruction();
+}
+async function makeCloseAccountIx(mfProgram, accounts) {
+  const { marginfiAccount, feePayer, ...optionalAccounts } = accounts;
+  return mfProgram.methods.marginfiAccountClose().accounts({
+    marginfiAccount,
+    feePayer
+  }).accountsPartial(optionalAccounts).instruction();
+}
+async function makePulseHealthIx(mfProgram, accounts, remainingAccounts = []) {
+  return mfProgram.methods.lendingAccountPulseHealth().accounts({
+    marginfiAccount: accounts.marginfiAccount
+  }).remainingAccounts(remainingAccounts).instruction();
+}
+var instructions = {
+  makeDepositIx,
+  makeJuplendDepositIx,
+  makeDriftDepositIx,
+  makeKaminoDepositIx,
+  makeRepayIx,
+  makeWithdrawIx,
+  makeJuplendWithdrawIx,
+  makeDriftWithdrawIx,
+  makeKaminoWithdrawIx,
+  makeBorrowIx,
+  makeInitMarginfiAccountIx,
+  makeInitMarginfiAccountPdaIx,
+  makeLendingAccountLiquidateIx,
+  makeLendingAccountClearEmissionsIx,
+  makePoolAddBankIx,
+  makePoolConfigureBankIx,
+  makeBeginFlashLoanIx,
+  makeEndFlashLoanIx,
+  makeAccountTransferToNewAccountIx,
+  makeGroupInitIx,
+  makeCloseAccountIx,
+  makePoolAddPermissionlessStakedBankIx,
+  makeLendingPoolConfigureBankOracleIx,
+  makePulseHealthIx
+};
+var instructions_default = instructions;
+
+export { instructions_default as default };
+//# sourceMappingURL=instructions.js.map
+//# sourceMappingURL=instructions.js.map