The marginfi TypeScript SDK

npm install @mrgnlabs/marginfi-client-v2 @mrgnlabs/mrgn-common

yarn add @mrgnlabs/marginfi-client-v2 @mrgnlabs/mrgn-common

import { Connection } from "@solana/web3.js";
import { MarginfiClient, getConfig } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

const connection = new Connection(CLUSTER_CONNECTION, "confirmed");
const wallet = NodeWallet.local();
const config = getConfig("dev");
const client = await MarginfiClient.fetch(config, wallet, connection);

const marginfiAccount = await client.createMarginfiAccount();

const bankLabel = "SOL";
const bank = client.getBankByTokenSymbol(bankLabel);
if (!bank) throw Error(`${bankLabel} bank not found`);

await marginfiAccount.deposit(1, bank.address);

await marginfiAccount.borrow(1, bank.address);

import { Connection } from "@solana/web3.js";
import { MarginfiClient, getConfig } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

const CLUSTER_CONNECTION = <your-rpc-url>;

const main = async () => {
	const connection = new Connection(CLUSTER_CONNECTION, "confirmed");
	const wallet = NodeWallet.local();
	const config = getConfig("dev");
	const client = await MarginfiClient.fetch(config, wallet, connection); // initialize client
	
	const marginfiAccount = await client.createMarginfiAccount(); // create an account
	
	const bankLabel = "SOL";
	const bank = client.getBankByTokenSymbol(bankLabel);
	if (!bank) throw Error(`${bankLabel} bank not found`); // fetch a bank
	
	await marginfiAccount.deposit(1, bank.address); // make a deposit
	await marginfiAccount.borrow(1, bank.address); // borrow from a bank
};

main();

const connection = new Connection(CLUSTER_CONNECTION, "confirmed");
const wallet = NodeWallet.local()
const config = getConfig("dev");
const client = await MarginfiClient.fetch(config, wallet, connection);

import { Connection, PublicKey } from "@solana/web3.js";
import { MarginfiClient, getConfig, AccountType, Bank } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

const RPC_ENDPOINT = "<RPC-URL>";

async function main() {
    const connection = new Connection(RPC_ENDPOINT, "confirmed");
    const wallet = NodeWallet.local();
    const config = getConfig("production");
    const client = await MarginfiClient.fetch(config, wallet, connection);

    // Fetch all public keys of banks owned by the mfi program
    const bankPubKeys = await client.getAllProgramAccountAddresses(AccountType.Bank);

    const banks = await Promise.all(
        bankPubKeys.map(async (bankPubKey) => {
            try {
                // Fetch account data for each bank
                const accountInfo = await connection.getAccountInfo(bankPubKey);
                if (accountInfo === null) {
                    console.error(`Failed to fetch account info for ${bankPubKey.toString()}`);
                    return null;
                }

                // Parse account data using Bank.fromBuffer
                const bank = Bank.fromBuffer(bankPubKey, accountInfo.data);
                return bank;
            } catch (error) {
                console.error(`Error processing bank ${bankPubKey.toString()}:`, error);
                return null;
            }
        })
    );

    // Filter out any null values (failed fetches/parses)
    const validBanks = banks.filter(bank => bank !== null);
    validBanks.forEach((bank, index) => {
        console.log(`Bank ${index + 1}:`, bank);
    });
}

main().catch((e) => console.log(e));

import { PublicKey, Connection } from "@solana/web3.js";
import { MarginfiAccountWrapper, MarginfiClient, getConfig } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet, chunkedGetRawMultipleAccountInfos, chunks } from "@mrgnlabs/mrgn-common";
import fs from "fs";

const BANK_TOKEN = "SOL";

interface BankDepositor {
  wallet: string;
  userAccount: string;
  amount: number;
}

async function main() {
  const connection = new Connection("https://api.devnet.solana.com", "confirmed");
  const wallet = NodeWallet.local()
  const config = getConfig("dev");
  const client = await MarginfiClient.fetch(config, wallet, connection);

  const targetBank = client.getBankByTokenSymbol(BANK_TOKEN);
  if (!targetBank) {
    throw new Error(`Bank ${BANK_TOKEN} not found`);
  }

  console.log(`Fetching all marginfi accounts...`)
  const marginfiAccountAddresses = await client.getAllMarginfiAccountAddresses();
  console.log(`Found ${marginfiAccountAddresses.length} marginfi accounts`);

  const addressBatches = chunks(marginfiAccountAddresses, 25_000); // To avoid blowing memory

  const depositorFileName = `./marginfi_depositors_${BANK_TOKEN}_${Date.now()}.csv`;
  fs.writeFileSync(depositorFileName, "wallet,user_account,amount\n");

  for (let i = 0; i < addressBatches.length; i++) {
    const addressBatch = addressBatches[i];
    console.log(`Processing batch ${i + 1}/${addressBatches.length} of ${addressBatch.length} addresses`);

    const [_, accountInfoMap] = await chunkedGetRawMultipleAccountInfos(
      client.provider.connection,
      addressBatch.map((pk) => pk.toBase58())
    );

    let depositors: BankDepositor[] = [];
    for (const [address, accountInfo] of accountInfoMap) {
      const marginfiAccount = MarginfiAccountWrapper.fromAccountDataRaw(new PublicKey(address), client, accountInfo.data);
      const depositAmount = marginfiAccount.balances
        .find((b) => b.active && b.bankPk.equals(targetBank.address) && b.assetShares.gt(0))
        ?.computeQuantityUi(targetBank).assets;
      if (depositAmount) {
        depositors.push({
          wallet: marginfiAccount.authority.toString(),
          userAccount: marginfiAccount.address.toString(),
          amount: depositAmount.toNumber(),
        });
      }
    }
    const csvContent = depositors.map(depositor => `${depositor.wallet},${depositor.userAccount},${depositor.amount}`).join('\n');
    fs.appendFileSync(depositorFileName, csvContent);
  }
}

main().catch((e) => console.log(e));

import { Connection } from "@solana/web3.js";
import { MarginfiClient } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

async function main() {
	const connection = new Connection("<rpc-url>", "confirmed");
  const wallet = NodeWallet.local()
  const config = getConfig("<environment>");
  const client = await MarginfiClient.fetch(config, wallet, connection);

  console.log(`Using ${client.config.environment} environment; wallet: ${client.wallet.publicKey.toBase58()}`);

  const marginfiAccount = await client.createMarginfiAccount();

  const bankLabel1 = "SOL";
  const bank1 = client.getBankByTokenSymbol(bankLabel1);
  if (!bank1) throw Error(`${bankLabel1} bank not found`);
  const bankLabel2 = "USDC";
  const bank2 = client.getBankByTokenSymbol(bankLabel2);
  if (!bank2) throw Error(`${bankLabel2} bank not found`);

  await marginfiAccount.deposit(1, bank1.address);
  await marginfiAccount.deposit(2, bank2.address);

  await marginfiAccount.reload();

  marginfiAccount.activeBalances.forEach((balance) => {
    const bank = client.getBankByPk(balance.bankPk)!;
    const oraclePrice = client.getOraclePriceByBank(bank.address)!;
    const { assets, liabilities } = balance.computeUsdValue(bank, oraclePrice, MarginRequirementType.Equity);

    console.log(
      `Balance for ${shortenAddress(bank.mint)} (${shortenAddress(
        balance.bankPk
      )}) deposits: ${assets}, borrows: ${liabilities}`
    );
  });
}

main().catch((e) => console.log(e));

import { Connection } from "@solana/web3.js";
import { MarginfiClient, MarginfiAccountWrapper } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

const MFI_ACCOUNT_ADDRESS = "<account-address>"; // e.g., 3oS3RJ8UYrYw7TAQEVh6u6ifrHi35o3DnvqyqGti4Gwa

async function main() {
	const connection = new Connection("<rpc-url>", "confirmed");
	const wallet = NodeWallet.local()
	const config = getConfig("<environment>");
	const client = await MarginfiClient.fetch(config, wallet, connection);

  const marginfiAccount = await MarginfiAccountWrapper.fetch(MFI_ACCOUNT_ADDRESS, client);

  console.log("Account state:");
  console.log(marginfiAccount.describe());
}

main().catch((e) => console.log(e));

import { Connection } from "@solana/web3.js";
import { MarginfiClient, MarginfiAccountWrapper } from '@mrgnlabs/marginfi-client-v2';
import { NodeWallet } from "@mrgnlabs/mrgn-common";

async function main() {
  const connection = new Connection("<rpc-url>", "confirmed");
	const wallet = NodeWallet.local()
	const config = getConfig("<environment>");
	const client = await MarginfiClient.fetch(config, wallet, connection);

  const marginfiAccounts = await client.getMarginfiAccountsForAuthority();
  if (marginfiAccounts.length === 0) throw Error("No marginfi account found");

  const marginfiAccount = marginfiAccounts[0];

  const solBank = client.getBankByTokenSymbol("SOL");
  if (!solBank) throw Error("SOL bank not found");

  const amount = 10; // SOL

  const borrowIx = await marginfiAccount.makeBorrowIx(amount, solBank.address);
  const repayIx = await marginfiAccount.makeRepayIx(amount, solBank.address, true);

  const flashLoanTx = await marginfiAccount.buildFlashLoanTx({
    ixs: [...borrowIx.instructions, ...repayIx.instructions],
    signers: [],
  });

  await client.processTransaction(flashLoanTx);
}

main().catch((e) => console.log(e));