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

package/src/utils.ts

@@ -0,0 +1,249 @@
+import { BN, web3 } from "@coral-xyz/anchor";
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import Decimal from "decimal.js";
+import {
+  WrappedI80F48,
+  InterestRateConfig,
+  BankConfig,
+  Bank,
+  ClendAccount,
+  OracleSetup,
+  getOracle,
+  RiskTier,
+  BankOperationalState,
+  AssetTag,
+  TOKEN_PROGRAMS,
+  USDC_MINT,
+  JLP_MINT,
+  TOKEN_DECIMALS,
+} from "./state";
+import { ClendClient } from "./rpc";
+
+/**
+ * Get token program for a mint
+ */
+export function getTokenProgramForMint(mint: web3.PublicKey): web3.PublicKey {
+  if (mint.equals(USDC_MINT)) {
+    return TOKEN_PROGRAMS.USDC;
+  } else if (mint.equals(JLP_MINT)) {
+    return TOKEN_PROGRAMS.JLP;
+  } else {
+    throw new Error(`Unsupported mint: ${mint.toString()}`);
+  }
+}
+
+/**
+ * Get token decimals for a mint
+ */
+export function getTokenDecimalsForMint(mint: web3.PublicKey): number {
+  if (mint.equals(USDC_MINT)) {
+    return TOKEN_DECIMALS.USDC;
+  } else if (mint.equals(JLP_MINT)) {
+    return TOKEN_DECIMALS.JLP;
+  } else {
+    throw new Error(`Unsupported mint: ${mint.toString()}`);
+  }
+}
+
+const I80F48_FRACTIONAL_BYTES = 6;
+const I80F48_TOTAL_BYTES = 16;
+const I80F48_DIVISOR = new Decimal(2).pow(8 * I80F48_FRACTIONAL_BYTES);
+
+export function bigNumberToWrappedI80F48(value: BN | number): WrappedI80F48 {
+  let decimalValue = new Decimal(value.toString());
+  const isNegative = decimalValue.isNegative();
+
+  decimalValue = decimalValue.times(I80F48_DIVISOR);
+  let wrappedValue = new BN(decimalValue.round().toFixed()).toArray();
+
+  if (wrappedValue.length < I80F48_TOTAL_BYTES) {
+    const padding = Array(I80F48_TOTAL_BYTES - wrappedValue.length).fill(0);
+    wrappedValue.unshift(...padding);
+  }
+
+  if (isNegative) {
+    wrappedValue[wrappedValue.length - 1] |= 0x80;
+    wrappedValue = wrappedValue.map((v: number) => ~v & 0xff);
+  }
+
+  wrappedValue.reverse();
+
+  return { value: wrappedValue };
+}
+
+export function wrappedI80F48toBigNumber(wrapped: WrappedI80F48): BN | number {
+  let bytesLE = wrapped.value;
+  if (bytesLE.length !== I80F48_TOTAL_BYTES) {
+    throw new Error(`Expected a ${I80F48_TOTAL_BYTES}-byte buffer`);
+  }
+
+  let bytesBE = bytesLE.slice();
+  bytesBE.reverse();
+
+  let signChar = "";
+  const msb = bytesBE[0];
+  if (msb & 0x80) {
+    signChar = "-";
+    bytesBE = bytesBE.map((v) => ~v & 0xff);
+  }
+
+  let hex =
+    signChar +
+    "0x" +
+    bytesBE.map((v) => v.toString(16).padStart(2, "0")).join("");
+  let decoded = new Decimal(hex).dividedBy(I80F48_DIVISOR);
+  let value = decoded.toString();
+
+  // Check if the value has decimal places
+  if (value.includes(".")) {
+    return Number(value);
+  }
+
+  return new BN(value);
+}
+
+export function parseInterestRateConfig(data: any): InterestRateConfig {
+  return {
+    optimalUtilizationRate: data.optimalUtilizationRate,
+    plateauInterestRate: data.plateauInterestRate,
+    maxInterestRate: data.maxInterestRate,
+    insuranceFeeFixedApr: data.insuranceFeeFixedApr,
+    insuranceIrFee: data.insuranceIrFee,
+    protocolFixedFeeApr: data.protocolFixedFeeApr,
+    protocolIrFee: data.protocolIrFee,
+    protocolOriginationFee: data.protocolOriginationFee,
+  };
+}
+
+export function parseRiskTier(data: any): RiskTier {
+  // Handle number format
+  if (typeof data === "number") {
+    if (data === 0) return RiskTier.Collateral;
+    if (data === 1) return RiskTier.Isolated;
+    throw new Error(`Invalid risk tier number: ${data}`);
+  }
+
+  // Handle object format
+  if (data.collateral) {
+    return RiskTier.Collateral;
+  } else if (data.isolated) {
+    return RiskTier.Isolated;
+  }
+
+  throw new Error(`Invalid risk tier format: ${JSON.stringify(data)}`);
+}
+
+export function parseOperationalState(data: any): BankOperationalState {
+  // Handle number format
+  if (typeof data === "number") {
+    if (data === 0) return BankOperationalState.Paused;
+    if (data === 1) return BankOperationalState.Operational;
+    if (data === 2) return BankOperationalState.ReduceOnly;
+    throw new Error(`Invalid operational state number: ${data}`);
+  }
+
+  // Handle object format
+  if (data.paused) {
+    return BankOperationalState.Paused;
+  } else if (data.operational) {
+    return BankOperationalState.Operational;
+  } else if (data.reduceOnly) {
+    return BankOperationalState.ReduceOnly;
+  }
+
+  throw new Error(`Invalid operational state format: ${JSON.stringify(data)}`);
+}
+
+export function parseAssetTag(data: any): AssetTag {
+  // Handle number format
+  if (typeof data === "number") {
+    if (data === 0) return AssetTag.Default;
+    if (data === 1) return AssetTag.Sol;
+    if (data === 2) return AssetTag.Staked;
+    throw new Error(`Invalid asset tag number: ${data}`);
+  }
+
+  // Handle object format
+  if (data.default) {
+    return AssetTag.Default;
+  } else if (data.sol) {
+    return AssetTag.Sol;
+  } else if (data.staked) {
+    return AssetTag.Staked;
+  }
+
+  throw new Error(`Invalid asset tag format: ${JSON.stringify(data)}`);
+}
+
+export function parseOracleSetup(data: any): OracleSetup {
+  // Handle number format
+  if (typeof data === "number") {
+    if (data === 0) return OracleSetup.None;
+    if (data === 1) return OracleSetup.PythLegacy;
+    if (data === 2) return OracleSetup.PythPushOracle;
+    if (data === 3) return OracleSetup.StakedWithPythPush;
+    throw new Error(`Invalid oracle setup number: ${data}`);
+  }
+
+  // Handle object format
+  if (data.none) {
+    return OracleSetup.None;
+  } else if (data.pythLegacy) {
+    return OracleSetup.PythLegacy;
+  } else if (data.pythPushOracle) {
+    return OracleSetup.PythPushOracle;
+  } else if (data.stakedWithPythPush) {
+    return OracleSetup.StakedWithPythPush;
+  }
+
+  throw new Error(`Invalid oracle setup format: ${JSON.stringify(data)}`);
+}
+
+export function parseBankConfig(data: any): BankConfig {
+  return {
+    assetWeightInit: data.assetWeightInit,
+    assetWeightMaint: data.assetWeightMaint,
+    liabilityWeightInit: data.liabilityWeightInit,
+    liabilityWeightMaint: data.liabilityWeightMaint,
+    depositLimit: new BN(data.depositLimit),
+    interestRateConfig: parseInterestRateConfig(data.interestRateConfig),
+    operationalState: parseOperationalState(data.operationalState),
+    oracleSetup: parseOracleSetup(data.oracleSetup),
+    oracleKeys: data.oracleKeys.map((key: any) => new web3.PublicKey(key)),
+    borrowLimit: new BN(data.borrowLimit),
+    riskTier: parseRiskTier(data.riskTier),
+    assetTag: parseAssetTag(data.assetTag),
+    totalAssetValueInitLimit: new BN(data.totalAssetValueInitLimit),
+    oracleMaxAge: data.oracleMaxAge,
+  };
+}
+
+// only return active banks
+export function getClendAccountActiveBanks(
+  clendAccount: ClendAccount,
+): web3.PublicKey[] {
+  return clendAccount.lendingAccount.balances
+    .filter((balance) => balance.active)
+    .map((balance) => balance.bankPk);
+}
+
+export function getClendAccountRemainingAccounts(
+  banks: Bank[],
+): web3.AccountMeta[] {
+  const remainingAccounts: web3.AccountMeta[] = [];
+  for (const bank of banks) {
+    remainingAccounts.push({
+      pubkey: bank.key,
+      isWritable: true,
+      isSigner: false,
+    });
+    // fetch correct oracle from map
+    const oracle = getOracle(bank.mint);
+    remainingAccounts.push({
+      pubkey: oracle,
+      isWritable: false,
+      isSigner: false,
+    });
+  }
+  return remainingAccounts;
+}

package/test/bank.test.ts

@@ -0,0 +1,95 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import { BN } from '@coral-xyz/anchor';
+import * as math from '../src/math';
+import { bigNumberToWrappedI80F48 } from '../src/utils';
+
+describe('Bank Calculations', () => {
+  describe('calculateUtilizationRate', () => {
+    it('should return 0 when total supply is 0', () => {
+      expect(math.calculateUtilizationRate(0, 100)).to.equal(0);
+    });
+
+    it('should calculate utilization rate correctly', () => {
+      expect(math.calculateUtilizationRate(1000, 500)).to.equal(0.5);
+    });
+
+    it('should cap utilization rate at 1', () => {
+      expect(math.calculateUtilizationRate(1000, 1500)).to.equal(1);
+    });
+  });
+
+  describe('calculateAssetQuantity', () => {
+    it('should calculate asset quantity from number shares', () => {
+      const shares = 100;
+      const shareValue = bigNumberToWrappedI80F48(0.5);
+      expect(math.calculateAssetQuantity(shares, shareValue)).to.be.closeTo(50, 0.001);
+    });
+
+    it('should calculate asset quantity from BN shares', () => {
+      const shares = new BN(100);
+      const shareValue = bigNumberToWrappedI80F48(0.5);
+      expect(math.calculateAssetQuantity(shares, shareValue)).to.be.closeTo(50, 0.001);
+    });
+  });
+
+  describe('calculateLiabilityQuantity', () => {
+    it('should calculate liability quantity from number shares', () => {
+      const shares = 200;
+      const shareValue = bigNumberToWrappedI80F48(0.75);
+      expect(math.calculateLiabilityQuantity(shares, shareValue)).to.be.closeTo(150, 0.001);
+    });
+
+    it('should calculate liability quantity from BN shares', () => {
+      const shares = new BN(200);
+      const shareValue = bigNumberToWrappedI80F48(0.75);
+      expect(math.calculateLiabilityQuantity(shares, shareValue)).to.be.closeTo(150, 0.001);
+    });
+  });
+
+  describe('calculateTotalAssetQuantity', () => {
+    it('should calculate total asset quantity correctly', () => {
+      const totalAssetShares = bigNumberToWrappedI80F48(1000);
+      const assetShareValue = bigNumberToWrappedI80F48(0.25);
+      expect(math.calculateTotalAssetQuantity(totalAssetShares, assetShareValue)).to.be.closeTo(250, 0.001);
+    });
+  });
+
+  describe('calculateTotalLiabilityQuantity', () => {
+    it('should calculate total liability quantity correctly', () => {
+      const totalLiabilityShares = bigNumberToWrappedI80F48(500);
+      const liabilityShareValue = bigNumberToWrappedI80F48(0.3);
+      expect(math.calculateTotalLiabilityQuantity(totalLiabilityShares, liabilityShareValue)).to.be.closeTo(150, 0.001);
+    });
+  });
+
+  describe('calculateBankUtilizationRate', () => {
+    it('should calculate bank utilization rate correctly', () => {
+      const totalAssetShares = bigNumberToWrappedI80F48(1000);
+      const assetShareValue = bigNumberToWrappedI80F48(1);
+      const totalLiabilityShares = bigNumberToWrappedI80F48(500);
+      const liabilityShareValue = bigNumberToWrappedI80F48(1);
+      
+      expect(math.calculateBankUtilizationRate(
+        totalAssetShares,
+        assetShareValue,
+        totalLiabilityShares,
+        liabilityShareValue
+      )).to.be.closeTo(0.5, 0.001);
+    });
+
+    it('should return 0 when total assets are 0', () => {
+      const totalAssetShares = bigNumberToWrappedI80F48(0);
+      const assetShareValue = bigNumberToWrappedI80F48(1);
+      const totalLiabilityShares = bigNumberToWrappedI80F48(500);
+      const liabilityShareValue = bigNumberToWrappedI80F48(1);
+      
+      expect(math.calculateBankUtilizationRate(
+        totalAssetShares,
+        assetShareValue,
+        totalLiabilityShares,
+        liabilityShareValue
+      )).to.equal(0);
+    });
+  });
+}); 

package/test/interest-rate.test.ts

@@ -0,0 +1,114 @@
+import { expect } from 'chai';
+import { describe, it } from 'mocha';
+import * as math from '../src/math';
+import { bigNumberToWrappedI80F48 } from '../src/utils';
+
+describe('Interest Rate Calculations', () => {
+  describe('calculateBaseInterestRate', () => {
+    it('should calculate interest rate below optimal utilization', () => {
+      const utilizationRate = 0.3;
+      const optimalUtilizationRate = bigNumberToWrappedI80F48(0.8);
+      const plateauInterestRate = bigNumberToWrappedI80F48(0.05);
+      const maxInterestRate = bigNumberToWrappedI80F48(0.2);
+      
+      // Below optimal: (0.3 / 0.8) * 0.05 = 0.01875
+      expect(math.calculateBaseInterestRate(
+        utilizationRate,
+        optimalUtilizationRate,
+        plateauInterestRate,
+        maxInterestRate
+      )).to.be.closeTo(0.01875, 0.0001);
+    });
+
+    it('should calculate interest rate at optimal utilization', () => {
+      const utilizationRate = 0.8;
+      const optimalUtilizationRate = bigNumberToWrappedI80F48(0.8);
+      const plateauInterestRate = bigNumberToWrappedI80F48(0.05);
+      const maxInterestRate = bigNumberToWrappedI80F48(0.2);
+      
+      // At optimal: should equal plateau rate
+      expect(math.calculateBaseInterestRate(
+        utilizationRate,
+        optimalUtilizationRate,
+        plateauInterestRate,
+        maxInterestRate
+      )).to.be.closeTo(0.05, 0.0001);
+    });
+
+    it('should calculate interest rate above optimal utilization', () => {
+      const utilizationRate = 0.9;
+      const optimalUtilizationRate = bigNumberToWrappedI80F48(0.8);
+      const plateauInterestRate = bigNumberToWrappedI80F48(0.05);
+      const maxInterestRate = bigNumberToWrappedI80F48(0.2);
+      
+      // Above optimal: 0.05 + ((0.9 - 0.8) / (1 - 0.8)) * (0.2 - 0.05) = 0.05 + (0.1 / 0.2) * 0.15 = 0.05 + 0.075 = 0.125
+      expect(math.calculateBaseInterestRate(
+        utilizationRate,
+        optimalUtilizationRate,
+        plateauInterestRate,
+        maxInterestRate
+      )).to.be.closeTo(0.125, 0.0001);
+    });
+
+    it('should calculate interest rate at max utilization', () => {
+      const utilizationRate = 1;
+      const optimalUtilizationRate = bigNumberToWrappedI80F48(0.8);
+      const plateauInterestRate = bigNumberToWrappedI80F48(0.05);
+      const maxInterestRate = bigNumberToWrappedI80F48(0.2);
+      
+      // At max: should equal max rate
+      expect(math.calculateBaseInterestRate(
+        utilizationRate,
+        optimalUtilizationRate,
+        plateauInterestRate,
+        maxInterestRate
+      )).to.be.closeTo(0.2, 0.0001);
+    });
+  });
+
+  describe('calculateSupplyApy', () => {
+    it('should calculate supply APY correctly', () => {
+      const utilizationRate = 0.7;
+      const baseInterestRate = 0.1;
+      const protocolIrFee = bigNumberToWrappedI80F48(0.1); // 10% fee
+      const insuranceIrFee = bigNumberToWrappedI80F48(0.05); // 5% fee
+      
+      // Supply APY = 0.1 * 0.7 * (1 - (0.1 + 0.05)) = 0.07 * 0.85 = 0.0595
+      expect(math.calculateSupplyApy(
+        utilizationRate,
+        baseInterestRate,
+        protocolIrFee,
+        insuranceIrFee
+      )).to.be.closeTo(0.0595, 0.0001);
+    });
+
+    it('should return 0 when utilization rate is 0', () => {
+      const utilizationRate = 0;
+      const baseInterestRate = 0.1;
+      const protocolIrFee = bigNumberToWrappedI80F48(0.1);
+      const insuranceIrFee = bigNumberToWrappedI80F48(0.05);
+      
+      expect(math.calculateSupplyApy(
+        utilizationRate,
+        baseInterestRate,
+        protocolIrFee,
+        insuranceIrFee
+      )).to.be.closeTo(0, 0.0001);
+    });
+  });
+
+  describe('calculateBorrowApy', () => {
+    it('should calculate borrow APY correctly', () => {
+      const baseInterestRate = 0.08;
+      const protocolFixedFeeApr = bigNumberToWrappedI80F48(0.01); // 1% fee
+      const insuranceFeeFixedApr = bigNumberToWrappedI80F48(0.005); // 0.5% fee
+      
+      // Borrow APY = 0.08 + 0.01 + 0.005 = 0.095
+      expect(math.calculateBorrowApy(
+        baseInterestRate,
+        protocolFixedFeeApr,
+        insuranceFeeFixedApr
+      )).to.be.closeTo(0.095, 0.0001);
+    });
+  });
+});