@carrot-protocol/clend-vaults-rpc 0.0.2 → 0.0.3-pub2-dev-be4bd59

package/src/math.ts

@@ -1,103 +0,0 @@
-import { LendingAccount } from "@carrot-protocol/clend-rpc";
-import { BN } from "@coral-xyz/anchor";
-
-/**
- * Computes the net asset value (NAV) per share based on vault equity and share supply.
- */
-export function calculateVaultNav(
-  equity: number,
-  sharesSupplyUi: number,
-): number {
-  if (equity === 0 || sharesSupplyUi === 0) {
-    return 0;
-  }
-  return equity / sharesSupplyUi;
-}
-
-/**
- * Calculates the USD value earned from a given number of shares and NAV.
- */
-export function usdEarned(sharesUi: number, nav: number): number {
-  return sharesUi * nav;
-}
-
-/**
- * Convert a UI number to a token amount BN
- * @param uiAmount Amount in UI format (e.g., 1.5 USDC)
- * @param decimals Token decimals
- * @returns BN representing the token amount in smallest units (lamports)
- */
-export function uiToAmount(uiAmount: number, decimals: number): BN {
-  // floor to avoid over-minting
-  return new BN(Math.floor(uiAmount * 10 ** decimals));
-}
-
-/**
- * Convert a token amount BN to a UI number
- * @param amount BN representing the token amount in smallest units (lamports)
- * @param decimals Token decimals
- * @returns Number in UI format (e.g., 1.5 USDC)
- */
-export function amountToUi(amount: BN, decimals: number): number {
-  return amount.toNumber() / 10 ** decimals;
-}
-
-export function calculateLendingAccountEquity(
-  lendingAccount: LendingAccount,
-): number {
-  let accountEquity = 0;
-  for (const balance of lendingAccount.balances) {
-    accountEquity =
-      accountEquity + (balance.assetValue - balance.liabilityValue);
-  }
-  return accountEquity;
-}
-
-/**
- * Converts a token amount to its USD value based on price and decimals.
- */
-export function amountToUsd(
-  amount: BN,
-  decimals: number,
-  price: number,
-): number {
-  return amountToUi(amount, decimals) * price;
-}
-
-/**
- * Converts a USD amount to its token representation based on price and decimals.
- */
-export function usdToAmount(
-  usdAmount: number,
-  decimals: number,
-  price: number,
-): BN {
-  return uiToAmount(usdAmount / price, decimals);
-}
-
-/**
- * Converts shares to asset tokens.
- */
-export function convertSharesToAsset(
-  vaultNav: number,
-  sharesAmountUi: number,
-  assetDecimals: number,
-  assetPrice: number,
-): BN {
-  const sharesUsd = usdEarned(sharesAmountUi, vaultNav);
-
-  const tokenAmount = usdToAmount(sharesUsd, assetDecimals, assetPrice);
-
-  return tokenAmount;
-}
-
-export function convertAssetToShares(
-  vaultNav: number,
-  assetAmount: BN,
-  assetDecimals: number,
-  sharesDecimals: number,
-  assetPrice: number,
-): BN {
-  const assetUsd = amountToUsd(assetAmount, assetDecimals, assetPrice);
-  return usdToAmount(assetUsd, sharesDecimals, vaultNav);
-}

package/src/program.ts

@@ -1,551 +0,0 @@
-// instructions.ts
-import { AnchorProvider, BN, Program, web3 } from "@coral-xyz/anchor";
-import {
-  AuthorityType,
-  createAssociatedTokenAccountIdempotentInstruction,
-  createSetAuthorityInstruction,
-  getAssociatedTokenAddressSync,
-  TOKEN_2022_PROGRAM_ID,
-} from "@solana/spl-token";
-import { getVaultPda, JUPITER_SWAP_PROGRAM_ID } from "./addresses";
-import { type ClendVaults } from "./idl/clend_vaults";
-import idl from "./idl/clend_vaults.json";
-import { Vault } from "./state";
-import {
-  CLEND_PROGRAM_ID,
-  getBankLiquidityVaultAuthorityPda,
-  getBankLiquidityVaultPda,
-  getBankPda,
-} from "@carrot-protocol/clend-rpc";
-import { getDummyProvider } from "./utils";
-
-export class ClendVaultsProgram {
-  readonly program: Program<ClendVaults>;
-
-  constructor(provider?: AnchorProvider) {
-    if (!provider) {
-      provider = getDummyProvider();
-    }
-    this.program = new Program<ClendVaults>(idl, provider);
-  }
-
-  async initVault(
-    vaultSharesMint: web3.PublicKey,
-    manager: web3.PublicKey,
-    managementFeeBps: number,
-  ): Promise<{ vault: web3.PublicKey; ixns: web3.TransactionInstruction[] }> {
-    const vault = getVaultPda(vaultSharesMint);
-
-    const transferMintAuthorityIx = createSetAuthorityInstruction(
-      vaultSharesMint,
-      manager,
-      AuthorityType.MintTokens,
-      vault,
-      [],
-      TOKEN_2022_PROGRAM_ID,
-    );
-
-    const args = {
-      managementFeeBps,
-    };
-
-    const ix = await this.program.methods
-      .initVault(args)
-      .accountsStrict({
-        manager,
-        payer: manager,
-        vault,
-        vaultShares: vaultSharesMint,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction();
-
-    return { vault, ixns: [transferMintAuthorityIx, ix] };
-  }
-
-  async addAsset(
-    vault: web3.PublicKey,
-    manager: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    assetOracle: web3.PublicKey,
-    assetTokenProgram: web3.PublicKey,
-    addAssetArgs: AddAssetArgs,
-  ): Promise<web3.TransactionInstruction[]> {
-    const vaultAssetReserve = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      assetTokenProgram,
-    );
-
-    // Create ATA idempotently
-    const createVaultReserveIx =
-      createAssociatedTokenAccountIdempotentInstruction(
-        manager, // payer
-        vaultAssetReserve,
-        vault,
-        assetMint,
-        assetTokenProgram,
-      );
-
-    const addAssetIx = await this.program.methods
-      .addAsset(addAssetArgs)
-      .accountsStrict({
-        vault,
-        assetMint,
-        assetOracle,
-        vaultAssetReserve,
-        manager,
-        tokenProgram: assetTokenProgram,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction();
-
-    return [createVaultReserveIx, addAssetIx];
-  }
-
-  async addClendAccount(
-    vault: web3.PublicKey,
-    manager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.Keypair,
-  ): Promise<web3.TransactionInstruction[]> {
-    const ix = await this.program.methods
-      .addClendAccount()
-      .accountsStrict({
-        vault,
-        clendAccount: clendAccount.publicKey,
-        clendGroup,
-        manager,
-        clendProgram: CLEND_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction();
-
-    return [ix];
-  }
-
-  async updateVaultManager(
-    vault: web3.PublicKey,
-    currentManager: web3.PublicKey,
-    newManager: web3.PublicKey,
-  ): Promise<web3.TransactionInstruction[]> {
-    const ix = await this.program.methods
-      .updateVaultManager()
-      .accountsStrict({
-        vault,
-        newManager,
-        manager: currentManager,
-      })
-      .instruction();
-    return [ix];
-  }
-
-  // -----------------
-  // Shares ops
-  // -----------------
-
-  async issue(
-    vault: web3.PublicKey,
-    sharesMint: web3.PublicKey,
-    user: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    assetOracle: web3.PublicKey,
-    amount: BN | number,
-    assetTokenProgram: web3.PublicKey,
-    sharesTokenProgram: web3.PublicKey,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const amt = new BN(amount as any);
-
-    // Vault reserve (owner is vault PDA)
-    const vaultAssetReserve = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      assetTokenProgram,
-    );
-
-    // User ATAs (owner is user)
-    const userAssetAccount = getAssociatedTokenAddressSync(
-      assetMint,
-      user,
-      true,
-      assetTokenProgram,
-    );
-    const userSharesAccount = getAssociatedTokenAddressSync(
-      sharesMint,
-      user,
-      true,
-      sharesTokenProgram,
-    );
-
-    // Ensure user's ATAs exist (idempotent)
-    const createUserAssetIx = createAssociatedTokenAccountIdempotentInstruction(
-      user,
-      userAssetAccount,
-      user,
-      assetMint,
-      assetTokenProgram,
-    );
-    const createUserSharesIx =
-      createAssociatedTokenAccountIdempotentInstruction(
-        user,
-        userSharesAccount,
-        user,
-        sharesMint,
-        sharesTokenProgram,
-      );
-
-    const ix = await this.program.methods
-      .issue({ amount: amt })
-      .accountsStrict({
-        vault,
-        shares: sharesMint,
-        assetMint,
-        assetOracle,
-        vaultAssetReserve,
-        userAssetAccount,
-        userSharesAccount,
-        user,
-        assetTokenProgram,
-        sharesTokenProgram,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [createUserAssetIx, createUserSharesIx, ix];
-  }
-
-  async redeem(
-    vault: web3.PublicKey,
-    sharesMint: web3.PublicKey,
-    user: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    assetOracle: web3.PublicKey,
-    amount: BN,
-    assetTokenProgram: web3.PublicKey,
-    sharesTokenProgram: web3.PublicKey,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const amt = new BN(amount as any);
-
-    const vaultAssetReserve = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      assetTokenProgram,
-    );
-    const userAssetAccount = getAssociatedTokenAddressSync(
-      assetMint,
-      user,
-      true,
-      assetTokenProgram,
-    );
-    const userSharesAccount = getAssociatedTokenAddressSync(
-      sharesMint,
-      user,
-      true,
-      sharesTokenProgram,
-    );
-
-    // Make sure the user asset ATA exists
-    const createUserAssetIx = createAssociatedTokenAccountIdempotentInstruction(
-      user,
-      userAssetAccount,
-      user,
-      assetMint,
-      assetTokenProgram,
-    );
-
-    const ix = await this.program.methods
-      .redeem({ amount: amt })
-      .accountsStrict({
-        vault,
-        shares: sharesMint,
-        assetMint,
-        assetOracle,
-        vaultAssetReserve,
-        userAssetAccount,
-        userSharesAccount,
-        user,
-        assetTokenProgram,
-        sharesTokenProgram,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [createUserAssetIx, ix];
-  }
-
-  // -----------------
-  // Clend-account ops (builders; vault PDA signs via seeds)
-  // -----------------
-
-  async clendAccountDeposit(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    assetMintTokenProgram: web3.PublicKey,
-    amount: BN,
-    vaultReserve: web3.PublicKey,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const bank = getBankPda(clendGroup, assetMint);
-    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
-
-    const ix = await this.program.methods
-      .clendAccountDeposit({ amount })
-      .accountsStrict({
-        vault,
-        assetMint,
-        clendGroup,
-        clendAccount,
-        bank,
-        vaultReserve,
-        bankLiquidityVault,
-        manager: vaultManager,
-        tokenProgram: assetMintTokenProgram,
-        clendProgram: CLEND_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [ix];
-  }
-
-  async clendAccountWithdraw(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    assetMintTokenProgram: web3.PublicKey,
-    amount: BN,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const bank = getBankPda(clendGroup, assetMint);
-    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
-    const bankLiquidityVaultAuthority = getBankLiquidityVaultAuthorityPda(bank);
-
-    const destinationTokenAccount = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      assetMintTokenProgram,
-    );
-
-    const ix = await this.program.methods
-      .clendAccountWithdraw({ amount })
-      .accountsStrict({
-        vault,
-        assetMint,
-        clendGroup,
-        clendAccount,
-        bank,
-        destinationTokenAccount,
-        bankLiquidityVaultAuthority,
-        bankLiquidityVault,
-        manager: vaultManager,
-        tokenProgram: assetMintTokenProgram,
-        clendProgram: CLEND_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [ix];
-  }
-
-  async clendAccountRepay(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    mintTokenProgram: web3.PublicKey,
-    amount: BN,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const bank = getBankPda(clendGroup, assetMint);
-    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
-
-    const signerTokenAccount = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      mintTokenProgram,
-    );
-
-    const ix = await this.program.methods
-      .clendAccountRepay({ amount: new BN(amount as any) })
-      .accountsStrict({
-        vault,
-        assetMint,
-        clendGroup,
-        clendAccount,
-        bank,
-        signerTokenAccount,
-        bankLiquidityVault,
-        manager: vaultManager,
-        tokenProgram: mintTokenProgram,
-        clendProgram: CLEND_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [ix];
-  }
-
-  async clendAccountBorrow(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    mintTokenProgram: web3.PublicKey,
-    amount: BN,
-    remainingAccounts: web3.AccountMeta[],
-  ): Promise<web3.TransactionInstruction[]> {
-    const bank = getBankPda(clendGroup, assetMint);
-    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
-    const bankLiquidityVaultAuthority = getBankLiquidityVaultAuthorityPda(bank);
-
-    const destinationTokenAccount = getAssociatedTokenAddressSync(
-      assetMint,
-      vault,
-      true,
-      mintTokenProgram,
-    );
-
-    const ix = await this.program.methods
-      .clendAccountBorrow({ amount })
-      .accountsStrict({
-        vault,
-        assetMint,
-        clendGroup,
-        clendAccount,
-        bank,
-        destinationTokenAccount,
-        bankLiquidityVaultAuthority,
-        bankLiquidityVault,
-        manager: vaultManager,
-        tokenProgram: mintTokenProgram,
-        clendProgram: CLEND_PROGRAM_ID,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [ix];
-  }
-
-  async clendAccountClaimEmissions(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey,
-    bank: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    emissionsMint: web3.PublicKey,
-    destinationAccount: web3.PublicKey, // vault-owned ATA for emissions mint
-    mintTokenProgram: web3.PublicKey,
-    emissionsVault: web3.PublicKey,
-    emissionsAuthority: web3.PublicKey,
-    clendProgramId: web3.PublicKey,
-  ): Promise<web3.TransactionInstruction[]> {
-    const ix = await this.program.methods
-      .clendAccountClaimEmissions()
-      .accountsStrict({
-        vault,
-        assetMint,
-        clendGroup,
-        clendAccount,
-        bank,
-        emissionsMint,
-        emissionsAuth: emissionsAuthority,
-        emissionsVault,
-        destinationAccount,
-        manager: vaultManager,
-        tokenProgram: mintTokenProgram,
-        clendProgram: clendProgramId,
-        systemProgram: web3.SystemProgram.programId,
-      })
-      .instruction();
-
-    return [ix];
-  }
-
-  async swap(
-    vault: web3.PublicKey,
-    vaultManager: web3.PublicKey,
-    assetInMint: web3.PublicKey,
-    assetOutMint: web3.PublicKey,
-    vaultAssetInReserve: web3.PublicKey,
-    vaultAssetOutReserve: web3.PublicKey,
-    swapData: Buffer,
-    remainingAccounts: web3.AccountMeta[],
-    swapProgram: web3.PublicKey = JUPITER_SWAP_PROGRAM_ID,
-  ): Promise<web3.TransactionInstruction[]> {
-    const ix = await this.program.methods
-      .swap({ swapData: Buffer.from(swapData) })
-      .accountsStrict({
-        vault,
-        assetInMint,
-        assetOutMint,
-        vaultAssetInReserve,
-        vaultAssetOutReserve,
-        manager: vaultManager,
-        swapProgram,
-      })
-      .remainingAccounts(remainingAccounts)
-      .instruction();
-
-    return [ix];
-  }
-
-  async distributeFees(
-    vault: web3.PublicKey,
-    manager: web3.PublicKey,
-    shares: web3.PublicKey,
-    sharesDestinationOwner: web3.PublicKey,
-  ): Promise<web3.TransactionInstruction[]> {
-    const sharesDestination = getAssociatedTokenAddressSync(
-      shares,
-      sharesDestinationOwner,
-      true,
-      TOKEN_2022_PROGRAM_ID,
-    );
-    const createSharesDestinationIx =
-      createAssociatedTokenAccountIdempotentInstruction(
-        manager,
-        sharesDestination,
-        sharesDestinationOwner,
-        shares,
-        TOKEN_2022_PROGRAM_ID,
-      );
-    const ix = await this.program.methods
-      .distributeFees()
-      .accountsStrict({
-        vault,
-        manager,
-        shares,
-        sharesDestination,
-        tokenProgram: TOKEN_2022_PROGRAM_ID,
-      })
-      .instruction();
-
-    return [createSharesDestinationIx, ix];
-  }
-}
-
-export interface AddAssetArgs {
-  issueFeeBps: number;
-  redemptionFeeBps: number;
-}