@carrot-protocol/clend-rpc 0.0.1-mrgn-fork1-dev-7be6ef2

package/src/index.ts

@@ -0,0 +1,31 @@
+export { ClendClient } from "./rpc";
+export { Instructions } from "./instructions";
+export { MockJupiterUtils } from "./mockJupiterUtils";
+export {
+  IJupiterUtils,
+  JupiterUtils,
+  SwapInputs,
+  SwapQuote,
+  SwapIxs,
+} from "./jupiterUtils";
+export * from "./addresses";
+export {
+  BankConfigCompact,
+  ClendGroup,
+  Bank,
+  ClendAccount,
+  FeeState,
+  Balance,
+  newInterestRateConfigCompact,
+  newBankConfigCompact,
+  RiskTier,
+  BankOperationalState,
+  AssetTag,
+  newClendAccountBalance,
+  InterestRateConfigCompact,
+  TOKEN_DECIMALS,
+  TOKEN_PROGRAMS,
+  USDC_MINT,
+  JLP_MINT,
+} from "./state";
+export * from "./math";

package/src/instructions.ts

@@ -0,0 +1,466 @@
+import { AnchorProvider, Program, web3, BN } from "@coral-xyz/anchor";
+import { Clend, IDL } from "./idl/clend";
+import {
+  CLEND_PROGRAM_ID,
+  getBankFeeVaultAuthorityPda,
+  getBankFeeVaultPda,
+  getBankInsuranceVaultAuthorityPda,
+  getBankInsuranceVaultPda,
+  getBankLiquidityVaultAuthorityPda,
+  getBankLiquidityVaultPda,
+  getBankPda,
+  getFeeStatePda,
+} from "./addresses";
+import { bigNumberToWrappedI80F48, getTokenProgramForMint } from "./utils";
+import {
+  BankConfigCompact,
+  BankOperationalState,
+  InterestRateConfigCompact,
+  InterestRateConfigOpt,
+  OracleSetup,
+  RiskTier,
+} from "./state";
+import { createInitializeAccount3Instruction } from "@solana/spl-token";
+
+// Types for configuration
+export type GroupConfig = {
+  admin?: web3.PublicKey;
+};
+
+export type FeeStateConfig = {
+  admin: web3.PublicKey;
+  feeWallet: web3.PublicKey;
+  bankInitFlatSolFee: number;
+  programFeeFixed: BN;
+  programFeeRate: BN;
+};
+
+export class Instructions {
+  readonly program: Program<Clend>;
+
+  constructor(provider: AnchorProvider) {
+    this.program = new Program(IDL, CLEND_PROGRAM_ID, provider);
+  }
+
+  // Group Instructions
+  async initializeGroup(
+    clendGroup: web3.Keypair,
+    admin: web3.PublicKey,
+    feeState: web3.PublicKey,
+  ): Promise<web3.TransactionInstruction> {
+    return this.program.methods
+      .clendGroupInitialize()
+      .accounts({
+        clendGroup: clendGroup.publicKey,
+        admin,
+        feeState,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .signers([clendGroup])
+      .instruction();
+  }
+
+  async configureGroup(
+    clendGroup: web3.PublicKey,
+    admin: web3.PublicKey,
+    config: GroupConfig,
+  ): Promise<web3.TransactionInstruction> {
+    return this.program.methods
+      .clendGroupConfigure(config)
+      .accounts({
+        clendGroup,
+        admin,
+      })
+      .instruction();
+  }
+
+  // Fee State Instructions
+  async initGlobalFeeState(
+    admin: web3.PublicKey,
+    feeWallet: web3.PublicKey,
+    bankInitFlatSolFee: number,
+    programFeeFixed: BN,
+    programFeeRate: BN,
+  ): Promise<web3.TransactionInstruction> {
+    const feeState = getFeeStatePda();
+
+    const programFeeFixedWrapped = bigNumberToWrappedI80F48(programFeeFixed);
+    const programFeeRateWrapped = bigNumberToWrappedI80F48(programFeeRate);
+
+    return this.program.methods
+      .initGlobalFeeState(
+        admin,
+        feeWallet,
+        bankInitFlatSolFee,
+        programFeeFixedWrapped,
+        programFeeRateWrapped,
+      )
+      .accounts({
+        feeState,
+        payer: admin,
+        rent: web3.SYSVAR_RENT_PUBKEY,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .instruction();
+  }
+
+  // Bank Instructions
+  async addBank(
+    clendGroup: web3.PublicKey,
+    admin: web3.PublicKey,
+    globalFeeWallet: web3.PublicKey,
+    bankMint: web3.PublicKey,
+    tokenProgram: web3.PublicKey,
+    pythOracle: web3.PublicKey,
+    pythOracleFeedId: web3.PublicKey,
+    bankConfig: BankConfigCompact,
+    interestRateConfig: InterestRateConfigCompact,
+  ): Promise<{ bank: web3.PublicKey; ixns: web3.TransactionInstruction[] }> {
+    const bank = getBankPda(clendGroup, bankMint);
+    const liquidityVault = getBankLiquidityVaultPda(bank);
+    const insuranceVault = getBankInsuranceVaultPda(bank);
+    const feeVault = getBankFeeVaultPda(bank);
+    const liquidityVaultAuthority = getBankLiquidityVaultAuthorityPda(bank);
+    const insuranceVaultAuthority = getBankInsuranceVaultAuthorityPda(bank);
+    const feeVaultAuthority = getBankFeeVaultAuthorityPda(bank);
+    const feeState = getFeeStatePda();
+
+    const formattedConfig = {
+      ...bankConfig,
+      operationalState: formatBankOperationalState(bankConfig.operationalState),
+      riskTier: formatRiskTier(bankConfig.riskTier),
+    };
+
+    const addBankIx = await this.program.methods
+      .lendingPoolAddBankWithSeed(formattedConfig, interestRateConfig)
+      .accounts({
+        clendGroup,
+        admin,
+        feeState,
+        globalFeeWallet,
+        bankMint,
+        bank,
+        liquidityVaultAuthority,
+        liquidityVault,
+        insuranceVaultAuthority,
+        insuranceVault,
+        feeVaultAuthority,
+        feeVault,
+        tokenProgram,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .instruction();
+
+    const configBankOracleIx = await this.configureBankOracle(
+      clendGroup,
+      admin,
+      bank,
+      pythOracle,
+      pythOracleFeedId,
+    );
+
+    return {
+      bank,
+      ixns: [addBankIx, configBankOracleIx],
+    };
+  }
+
+  async configureBankOracle(
+    clendGroup: web3.PublicKey,
+    admin: web3.PublicKey,
+    bank: web3.PublicKey,
+    pythOracle: web3.PublicKey,
+    pythOracleFeedId: web3.PublicKey,
+  ): Promise<web3.TransactionInstruction> {
+    // hardcode this type for now
+    const oracleSetup = OracleSetup.PythPushOracle;
+
+    const oracleRA: web3.AccountMeta = {
+      isSigner: false,
+      isWritable: false,
+      pubkey: pythOracle,
+    };
+
+    const ix = await this.program.methods
+      .lendingPoolConfigureBankOracle(oracleSetup, pythOracleFeedId)
+      .accounts({
+        group: clendGroup,
+        admin,
+        bank,
+      })
+      .remainingAccounts([oracleRA])
+      .instruction();
+    return ix;
+  }
+
+  // Account Instructions
+  async initializeClendAccount(
+    clendGroup: web3.PublicKey,
+    authority: web3.PublicKey,
+    clendAccount: web3.Keypair,
+  ): Promise<web3.TransactionInstruction> {
+    return this.program.methods
+      .clendAccountInitialize()
+      .accounts({
+        clendGroup,
+        authority,
+        clendAccount: clendAccount.publicKey,
+        feePayer: authority,
+        systemProgram: web3.SystemProgram.programId,
+      })
+      .signers([clendAccount])
+      .instruction();
+  }
+
+  // Deposit/Withdraw/Borrow/Repay Instructions
+  async deposit(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    user: web3.PublicKey,
+    bank: web3.PublicKey,
+    userTokenAccount: web3.PublicKey,
+    tokenProgram: web3.PublicKey,
+    amount: BN,
+    remainingAccounts: web3.AccountMeta[],
+  ): Promise<web3.TransactionInstruction> {
+    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
+
+    return this.program.methods
+      .lendingAccountDeposit(amount)
+      .accounts({
+        clendGroup,
+        clendAccount,
+        signer: user,
+        bank,
+        signerTokenAccount: userTokenAccount,
+        bankLiquidityVault,
+        tokenProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+  }
+
+  async withdraw(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    user: web3.PublicKey,
+    bank: web3.PublicKey,
+    destinationTokenAccount: web3.PublicKey,
+    tokenProgram: web3.PublicKey,
+    amount: BN,
+    withdrawAll: boolean | null = null,
+    remainingAccounts: web3.AccountMeta[],
+  ): Promise<web3.TransactionInstruction> {
+    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
+    const bankLiquidityVaultAuthority = getBankLiquidityVaultAuthorityPda(bank);
+
+    return this.program.methods
+      .lendingAccountWithdraw(amount, withdrawAll)
+      .accounts({
+        clendGroup,
+        clendAccount,
+        signer: user,
+        bank,
+        bankLiquidityVault,
+        bankLiquidityVaultAuthority,
+        destinationTokenAccount,
+        tokenProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+  }
+
+  async borrow(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    user: web3.PublicKey,
+    bank: web3.PublicKey,
+    destinationTokenAccount: web3.PublicKey,
+    tokenProgram: web3.PublicKey,
+    amount: BN,
+    remainingAccounts: web3.AccountMeta[],
+  ): Promise<web3.TransactionInstruction> {
+    const bankLiquidityVaultAuthority = getBankLiquidityVaultAuthorityPda(bank);
+    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
+
+    return this.program.methods
+      .lendingAccountBorrow(amount)
+      .accounts({
+        clendGroup,
+        clendAccount,
+        signer: user,
+        bank,
+        destinationTokenAccount,
+        bankLiquidityVaultAuthority,
+        bankLiquidityVault,
+        tokenProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+  }
+
+  async repay(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    user: web3.PublicKey,
+    bank: web3.PublicKey,
+    userTokenAccount: web3.PublicKey,
+    tokenProgram: web3.PublicKey,
+    amount: BN,
+    repayAll: boolean | null = null,
+    remainingAccounts: web3.AccountMeta[],
+  ): Promise<web3.TransactionInstruction> {
+    const bankLiquidityVault = getBankLiquidityVaultPda(bank);
+
+    return this.program.methods
+      .lendingAccountRepay(amount, repayAll)
+      .accounts({
+        clendGroup,
+        clendAccount,
+        signer: user,
+        bank,
+        signerTokenAccount: userTokenAccount,
+        bankLiquidityVault,
+        tokenProgram,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+  }
+
+  // Flash Loan Instructions
+  async createFlashLoanInstructions(
+    clendAccount: web3.PublicKey,
+    user: web3.PublicKey,
+    endIndex: BN,
+    remainingAccounts: web3.AccountMeta[],
+  ): Promise<{
+    beginFlashLoanIx: web3.TransactionInstruction;
+    endFlashLoanIx: web3.TransactionInstruction;
+  }> {
+    const beginFlashLoanIx = await this.program.methods
+      .lendingAccountStartFlashloan(endIndex)
+      .accounts({
+        clendAccount,
+        signer: user,
+        ixsSysvar: web3.SYSVAR_INSTRUCTIONS_PUBKEY,
+      })
+      .instruction();
+
+    const endFlashLoanIx = await this.program.methods
+      .lendingAccountEndFlashloan()
+      .accounts({
+        clendAccount,
+        signer: user,
+      })
+      .remainingAccounts(remainingAccounts)
+      .instruction();
+
+    return {
+      beginFlashLoanIx,
+      endFlashLoanIx,
+    };
+  }
+
+  async configureBankInterestRate(
+    clendGroup: web3.PublicKey,
+    admin: web3.PublicKey,
+    bank: web3.PublicKey,
+    interestRateConfig: InterestRateConfigOpt,
+  ): Promise<web3.TransactionInstruction> {
+    return this.program.methods
+      .lendingPoolConfigureBankIr(interestRateConfig)
+      .accounts({
+        clendGroup,
+        admin,
+        bank,
+      })
+      .instruction();
+  }
+
+  async editGlobalFeeWallet(
+    admin: web3.PublicKey,
+    newGlobalFeeWallet: web3.PublicKey,
+  ): Promise<web3.TransactionInstruction> {
+    const feeState = getFeeStatePda();
+
+    return this.program.methods
+      .editGlobalFeeState(newGlobalFeeWallet, 10000, new BN(0), new BN(10000))
+      .accounts({
+        globalFeeAdmin: admin,
+        feeState,
+      })
+      .instruction();
+  }
+}
+
+export function formatBankOperationalState(state: number): any {
+  switch (state) {
+    case 0:
+      return { paused: {} };
+    case 1:
+      return { operational: {} };
+    case 2:
+      return { reduceOnly: {} };
+    default:
+      throw new Error(
+        `Invalid bank operational state: ${state}, expected 0 (Paused), 1 (Operational), or 2 (ReduceOnly)`,
+      );
+  }
+}
+
+export function parseBankOperationalState(state: any): BankOperationalState {
+  if ("paused" in state) {
+    return BankOperationalState.Paused;
+  }
+  if ("operational" in state) {
+    return BankOperationalState.Operational;
+  }
+  if ("reduceOnly" in state) {
+    return BankOperationalState.ReduceOnly;
+  }
+  throw new Error(
+    `Invalid bank operational state format: ${JSON.stringify(state)}, expected object with 'paused', 'operational', or 'reduceOnly' key`,
+  );
+}
+
+export function formatRiskTier(tier: number): any {
+  switch (tier) {
+    case 0:
+      return { collateral: {} };
+    case 1:
+      return { isolated: {} };
+    default:
+      throw new Error(
+        `Invalid risk tier: ${tier}, expected 0 (Collateral) or 1 (Isolated)`,
+      );
+  }
+}
+
+export function parseRiskTier(tier: any): RiskTier {
+  if ("collateral" in tier) {
+    return RiskTier.Collateral;
+  }
+  if ("isolated" in tier) {
+    return RiskTier.Isolated;
+  }
+  throw new Error(
+    `Invalid risk tier format: ${JSON.stringify(tier)}, expected object with 'collateral' or 'isolated' key`,
+  );
+}
+
+export function parseOracleSetup(setup: number): OracleSetup {
+  switch (setup) {
+    case 0:
+      return OracleSetup.None;
+    case 1:
+      return OracleSetup.PythLegacy;
+    case 2:
+      return OracleSetup.PythPushOracle;
+    case 3:
+      return OracleSetup.StakedWithPythPush;
+    default:
+      throw new Error(
+        `Invalid oracle setup value: ${setup}, expected 0, 1, 2, or 3`,
+      );
+  }
+}