@carrot-protocol/boost-http-client 0.2.15 → 0.2.16-group-refactor1-dev-50c976e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carrot-protocol/boost-http-client",
-  "version": "0.2.15",
+  "version": "0.2.16-group-refactor1-dev-50c976e",
   "description": "HTTP client for Carrot Boost",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -14,7 +14,7 @@
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.29.0",
-    "@carrot-protocol/clend-common": "0.1.8-group-refactor1-dev-19efede",
+    "@carrot-protocol/clend-common": "0.1.7",
     "axios": "^1.8.3",
     "bs58": "^6.0.0",
     "decimal.js": "^10.5.0"

package/src/index.ts

@@ -12,21 +12,13 @@ import {
   WithdrawLeverageResponse,
   UserWallet,
   ClendAccount,
-  ClendAccountBalance,
+  Balance,
   Bank,
   GetGroupResponse,
   ClendAccountEvent,
   GetUserRequest,
   ClendAccountTxSummary,
   UserRequest,
-  UserBalance,
-  ClendAccountAssetLiquidation,
-  GetGroupsResponse,
-  GroupAndBanks,
-  BankEmissions,
-  BankEmissionsMode,
-  WithdrawEmissionsRequest,
-  WithdrawEmissionsResponse,
 } from "./types";
 import encode from "bs58";
 
@@ -106,207 +98,153 @@ export class Client {
     return handleApiCall(() => this.http.get(""));
   }
 
-  async getUser(
-    user: web3.PublicKey,
-    groups: web3.PublicKey[],
-    getClendAccountSummary: boolean,
-  ): Promise<GetUserResponse> {
-    // Make the API call to fetch the raw user data as a string.
+  /**
+   * Get user details for a wallet
+   * @param user wallet public key
+   * @returns User details
+   */
+  async getUser(request: GetUserRequest): Promise<GetUserResponse> {
+    // use loaded wallet if not provided
+    let user = request.user;
+    if (!user) {
+      user = this.address();
+    }
+
     const body = await handleApiCall(() =>
       this.http.get(
-        `/user?user=${user.toString()}&groups=${groups.map((g) => g.toString()).join(",")}&getClendAccountSummary=${getClendAccountSummary}`,
+        `/user?user=${user.toString()}&getClendAccountSummary=${request.getClendAccountSummary}`,
       ),
     );
 
-    // Parse the raw string body into a JSON object.
     const jsonRawResponse: any = JSON.parse(body);
 
-    // 1. Parse Wallet Balances
-    // This section correctly iterates through the wallet balances and creates typed objects.
-    const walletBalances: UserBalance[] = (
-      jsonRawResponse.wallet.balances || []
-    ).map((b: any) => ({
-      mint: new web3.PublicKey(b.mint),
-      balance: new BN(b.balance, "hex"),
-      balanceUi: Number(b.balanceUi),
-    }));
-
+    // get tokens still in user wallet
     const wallet: UserWallet = {
-      balances: walletBalances,
+      usdcBalance: new BN(jsonRawResponse.wallet.usdcBalance, "hex"),
+      usdcBalanceUi: Number(jsonRawResponse.wallet.usdcBalanceUi),
+      jlpBalance: new BN(jsonRawResponse.wallet.jlpBalance, "hex"),
+      jlpBalanceUi: Number(jsonRawResponse.wallet.jlpBalanceUi),
+      solBalance: new BN(jsonRawResponse.wallet.solBalance, "hex"),
+      solBalanceUi: Number(jsonRawResponse.wallet.solBalanceUi),
     };
 
-    // 2. Parse Clend Accounts and their Summaries
-    // This is the main refactored section. It iterates through the clendAccounts array
-    // from the response, which contains both the account data and its summary.
-    const clendAccounts = (jsonRawResponse.clendAccounts || []).map(
-      (accountData: any) => {
-        // A. Parse the main ClendAccount object
-        const rawClendAccount = accountData.clendAccount;
-        const clendAccountBalances: ClendAccountBalance[] = (
-          rawClendAccount.balances || []
-        ).map((b: any) => {
-          const liquidation: ClendAccountAssetLiquidation | null = b.liquidation
-            ? {
-                price: Number(b.liquidation.price),
-                changePercentage: Number(b.liquidation.changePercentage),
-              }
-            : null;
-
-          const emissionsOutstandingAndUnclaimed = new BN(
-            b.emissionsOutstandingAndUnclaimed,
-            "hex",
-          );
-
-          return {
-            mint: new web3.PublicKey(b.mint),
-            bank: new web3.PublicKey(b.bank),
-            tokenYieldApy: Number(b.tokenYieldApy),
-            assetBalance: new BN(b.assetBalance, "hex"),
-            assetBalanceUi: Number(b.assetBalanceUi),
-            assetValue: Number(b.assetValue),
-            assetEmissionsApy: Number(b.assetEmissionsApy),
-            liabilityBalance: new BN(b.liabilityBalance, "hex"),
-            liabilityBalanceUi: Number(b.liabilityBalanceUi),
-            liabilityValue: Number(b.liabilityValue),
-            liabilityBorrowCostApy: Number(b.liabilityBorrowCostApy),
-            liabilityEmissionsApy: Number(b.liabilityEmissionsApy),
-            emissionsOutstandingAndUnclaimed,
-            emissionsOutstandingAndUnclaimedUi: Number(
-              b.emissionsOutstandingAndUnclaimedUi,
-            ),
-            price: Number(b.price),
-            liquidation,
-          };
-        });
-
-        const clendAccount: ClendAccount = {
-          key: new web3.PublicKey(rawClendAccount.key),
-          group: new web3.PublicKey(rawClendAccount.group),
-          balances: clendAccountBalances,
-          netValue: Number(rawClendAccount.netValue),
-          netApy: Number(rawClendAccount.netApy),
-          pnl: Number(rawClendAccount.pnl),
-          totalEmissionsApy: Number(rawClendAccount.totalEmissionsApy),
-          totalAssetValue: Number(rawClendAccount.totalAssetValue),
-          totalLiabilityValue: Number(rawClendAccount.totalLiabilityValue),
-          healthFactorNotional: Number(rawClendAccount.healthFactorNotional),
-          healthFactorRiskAdjusted: Number(
-            rawClendAccount.healthFactorRiskAdjusted,
-          ),
-          notionalLeverage: Number(rawClendAccount.notionalLeverage),
-          riskAdjustedLeverage: Number(rawClendAccount.riskAdjustedLeverage),
-          notionalLtv: Number(rawClendAccount.notionalLtv),
-          riskAdjustedLtv: Number(rawClendAccount.riskAdjustedLtv),
+    // if no clend account, return undefined for clend
+    if (!jsonRawResponse.clendAccount) {
+      return {
+        wallet,
+        clendAccount: undefined,
+        summary: [],
+      };
+    }
+
+    // parse lending account balances
+    const balances: Balance[] = [];
+    for (const b of jsonRawResponse.clendAccount.balances) {
+      balances.push({
+        mint: new web3.PublicKey(b.mint),
+        bank: new web3.PublicKey(b.bank),
+        assetBalance: new BN(b.assetBalance, "hex"),
+        assetBalanceUi: Number(b.assetBalanceUi),
+        assetValue: Number(b.assetValue),
+        liabilityBalance: new BN(b.liabilityBalance, "hex"),
+        liabilityBalanceUi: Number(b.liabilityBalanceUi),
+        liabilityValue: Number(b.liabilityValue),
+        price: Number(b.price),
+      });
+    }
+
+    // create clend account
+    const clendAccount: ClendAccount = {
+      balances,
+      netValue: Number(jsonRawResponse.clendAccount.netValue),
+      netApy: Number(jsonRawResponse.clendAccount.netApy),
+      pnl: Number(jsonRawResponse.clendAccount.pnl),
+      totalAssetValue: Number(jsonRawResponse.clendAccount.totalAssetValue),
+      totalLiabilityValue: Number(
+        jsonRawResponse.clendAccount.totalLiabilityValue,
+      ),
+      healthFactorNotional: Number(
+        jsonRawResponse.clendAccount.healthFactorNotional,
+      ),
+      healthFactorRiskAdjusted: Number(
+        jsonRawResponse.clendAccount.healthFactorRiskAdjusted,
+      ),
+      notionalLeverage: Number(jsonRawResponse.clendAccount.notionalLeverage),
+      riskAdjustedLeverage: Number(
+        jsonRawResponse.clendAccount.riskAdjustedLeverage,
+      ),
+      liquidationPrice: Number(jsonRawResponse.clendAccount.liquidationPrice),
+      liquidationPriceChangePercentage: Number(
+        jsonRawResponse.clendAccount.liquidationPriceChangePercentage,
+      ),
+      notionalLtv: Number(jsonRawResponse.clendAccount.notionalLtv),
+      riskAdjustedLtv: Number(jsonRawResponse.clendAccount.riskAdjustedLtv),
+    };
+
+    // get tx summary for each account
+    const summary: ClendAccountTxSummary[] = [];
+    for (const s of jsonRawResponse.summary) {
+      const txSummary: ClendAccountTxSummary = {
+        txSig: s.txSig,
+        time: s.time,
+        clendAccount: new web3.PublicKey(s.clendAccount),
+        clendAccountAuthority: new web3.PublicKey(s.clendAccountAuthority),
+        clendGroup: new web3.PublicKey(s.clendGroup),
+        action: s.action,
+        input: undefined,
+        events: [],
+      };
+
+      // parse inputs if they exist
+      if (s.input) {
+        const input: UserRequest = {
+          apiPath: s.input.apiPath,
+          selectedTokenMint: s.input.selectedTokenMint
+            ? new web3.PublicKey(s.input.selectedTokenMint)
+            : null,
+          amountUi: s.input.amountUi ? Number(s.input.amountUi) : null,
+          leverage: s.input.leverage ? Number(s.input.leverage) : null,
+          slippageBps: s.input.slippageBps ? Number(s.input.slippageBps) : null,
+          openPosition: s.input.openPosition
+            ? Boolean(s.input.openPosition)
+            : null,
+          closePosition: s.input.closePosition
+            ? Boolean(s.input.closePosition)
+            : null,
         };
+        txSummary.input = input;
+      }
 
-        // B. Parse the associated Summary array for the account
-        let summary: ClendAccountTxSummary[] = [];
-        if (getClendAccountSummary && accountData.summary) {
-          summary = accountData.summary.map((s: any) => {
-            let input: UserRequest | undefined = undefined;
-            if (s.input) {
-              input = {
-                apiPath: s.input.apiPath,
-                selectedTokenMint: s.input.selectedTokenMint
-                  ? new web3.PublicKey(s.input.selectedTokenMint)
-                  : null,
-                amountUi: s.input.amountUi ? Number(s.input.amountUi) : null,
-                leverage: s.input.leverage ? Number(s.input.leverage) : null,
-                slippageBps: s.input.slippageBps
-                  ? Number(s.input.slippageBps)
-                  : null,
-                openPosition:
-                  s.input.openPosition != null
-                    ? Boolean(s.input.openPosition)
-                    : null,
-                closePosition:
-                  s.input.closePosition != null
-                    ? Boolean(s.input.closePosition)
-                    : null,
-              };
-            }
-
-            const events: ClendAccountEvent[] = (s.events || []).map(
-              (event: any) => {
-                let closeBalance: boolean | null = null;
-                // Only convert to boolean if the value is not null/undefined to preserve the null state.
-                if (
-                  event.closeBalance !== null &&
-                  event.closeBalance !== undefined
-                ) {
-                  closeBalance = Boolean(event.closeBalance);
-                }
-
-                return {
-                  eventIndex: event.eventIndex,
-                  eventName: event.eventName,
-                  bank: event.bank ? new web3.PublicKey(event.bank) : null,
-                  mint: event.mint ? new web3.PublicKey(event.mint) : null,
-                  amount: event.amount ? new BN(event.amount, "hex") : null,
-                  amountUi: event.amountUi ? Number(event.amountUi) : null,
-                  value: event.value ? Number(event.value) : null,
-                  price: event.price ? Number(event.price) : null,
-                  closeBalance,
-                };
-              },
-            );
-
-            const txSummary: ClendAccountTxSummary = {
-              txSig: s.txSig,
-              time: s.time,
-              clendAccount: new web3.PublicKey(s.clendAccount),
-              clendAccountAuthority: new web3.PublicKey(
-                s.clendAccountAuthority,
-              ),
-              clendGroup: new web3.PublicKey(s.clendGroup),
-              action: s.action,
-              input,
-              events,
-            };
-            return txSummary;
-          });
+      // get events for each summary
+      for (const event of s.events) {
+        let closeBalance: boolean | null = null;
+        if (event.closeBalance !== null) {
+          closeBalance = Boolean(event.closeBalance);
         }
 
-        // C. Combine the parsed account and its summary
-        return { clendAccount, summary };
-      },
-    );
+        // parse amount
+        const clendAccountEvent: ClendAccountEvent = {
+          eventIndex: event.eventIndex,
+          eventName: event.eventName,
+          bank: event.bank ? new web3.PublicKey(event.bank) : null,
+          mint: event.mint ? new web3.PublicKey(event.mint) : null,
+          amount: event.amount ? new BN(event.amount, "hex") : null,
+          amountUi: event.amountUi ? Number(event.amountUi) : null,
+          value: event.value ? Number(event.value) : null,
+          price: event.price ? Number(event.price) : null,
+          closeBalance,
+        };
+        txSummary.events.push(clendAccountEvent);
+      }
+      summary.push(txSummary);
+    }
 
-    // 3. Return the final, correctly structured response object.
     return {
       wallet,
-      clendAccounts,
+      clendAccount,
+      summary,
     };
   }
-  /**
-   * Get all groups
-   * @param includeBankData Whether to include bank data in the response, if not strictly necessary keep false
-   * @returns All groups
-   */
-  async getGroups(includeBankData: boolean): Promise<GetGroupsResponse> {
-    const body = await handleApiCall(() =>
-      this.http.get(`/groups?includeBankData=${includeBankData}`),
-    );
-
-    const marketJson: any = JSON.parse(body);
-    const groups: GroupAndBanks[] = [];
-    for (const groupJson of marketJson.groups) {
-      const group: web3.PublicKey = new web3.PublicKey(groupJson.group);
-      const groupName = groupJson.groupName;
-      const banks: Bank[] = [];
-      for (const bankJson of groupJson.banks) {
-        const bank = parseBank(bankJson);
-        banks.push(bank);
-      }
-      groups.push({ group, groupName, banks });
-    }
-
-    const response: GetGroupsResponse = {
-      groups,
-    };
-
-    return response;
-  }
 
   /**
    * Get market details
@@ -319,18 +257,14 @@ export class Client {
     );
 
     const marketJson: any = JSON.parse(body);
-    const group: GroupAndBanks = {
-      group: new web3.PublicKey(marketJson.group.group),
-      groupName: marketJson.group.groupName,
-      banks: [],
-    };
-    for (const bankJson of marketJson.group.banks) {
+    const banks: Bank[] = [];
+    for (const bankJson of marketJson.banks) {
       const bank = parseBank(bankJson);
-      group.banks.push(bank);
+      banks.push(bank);
     }
 
     const response: GetGroupResponse = {
-      group,
+      banks,
     };
 
     return response;
@@ -362,19 +296,14 @@ export class Client {
    * @returns Deposit leverage operation result
    */
   async depositLeverage(
-    clendGroup: web3.PublicKey,
-    clendAccount: web3.PublicKey | null,
-    inputTokenMint: web3.PublicKey,
-    assetTokenMint: web3.PublicKey,
-    liabilityTokenMint: web3.PublicKey,
+    inputMint: web3.PublicKey,
+    assetMint: web3.PublicKey,
+    liabilityMint: web3.PublicKey,
     uiAmount: number,
     leverage: number,
     slippageBps: number,
   ): Promise<string> {
-    if (
-      !inputTokenMint.equals(assetTokenMint) &&
-      !inputTokenMint.equals(liabilityTokenMint)
-    ) {
+    if (!inputMint.equals(assetMint) || !inputMint.equals(liabilityMint)) {
       throw new Error(
         "Input mint must be the same as the asset or liability mint",
       );
@@ -382,11 +311,9 @@ export class Client {
 
     const req: DepositLeverageRequest = {
       owner: this.address(),
-      clendGroup,
-      clendAccount,
-      inputTokenMint,
-      assetTokenMint,
-      liabilityTokenMint,
+      inputMint,
+      assetMint,
+      liabilityMint,
       depositAmountUi: uiAmount,
       leverage,
       slippageBps,
@@ -410,17 +337,9 @@ export class Client {
    * @param request Adjust leverage request parameters
    * @returns Adjust leverage operation result
    */
-  async adjustLeverage(
-    clendAccount: web3.PublicKey,
-    assetTokenMint: web3.PublicKey,
-    liabilityTokenMint: web3.PublicKey,
-    leverage: number,
-    slippageBps: number,
-  ): Promise<string> {
+  async adjustLeverage(leverage: number, slippageBps: number): Promise<any> {
     const req: AdjustLeverageRequest = {
-      clendAccount,
-      assetTokenMint,
-      liabilityTokenMint,
+      owner: this.address(),
       leverage,
       slippageBps,
     };
@@ -444,19 +363,14 @@ export class Client {
    * @returns Withdraw leverage operation result
    */
   async withdrawLeverage(
-    clendAccount: web3.PublicKey,
-    outputTokenMint: web3.PublicKey,
-    assetTokenMint: web3.PublicKey,
-    liabilityTokenMint: web3.PublicKey,
+    selectedTokenMint: web3.PublicKey,
     uiAmount: number,
     slippageBps: number,
     withdrawAll: boolean,
-  ): Promise<string> {
+  ): Promise<any> {
     const req: WithdrawLeverageRequest = {
-      clendAccount,
-      outputTokenMint,
-      assetTokenMint,
-      liabilityTokenMint,
+      owner: this.address(),
+      selectedTokenMint,
       withdrawAmountUi: uiAmount,
       slippageBps,
       withdrawAll,
@@ -474,30 +388,6 @@ export class Client {
 
     return txSig;
   }
-
-  /**
-   * Withdraw emissions from a bank
-   * @returns Withdraw emissions operation result
-   */
-  async withdrawEmissions(): Promise<string> {
-    const req: WithdrawEmissionsRequest = {
-      owner: this.address(),
-    };
-
-    const body = await handleApiCall(() =>
-      this.http.post("emissions/withdraw", JSON.stringify(req)),
-    );
-
-    const withdrawEmissionsResponse: WithdrawEmissionsResponse =
-      JSON.parse(body);
-
-    const txSig = await this.send(
-      withdrawEmissionsResponse.unsignedBase64Tx,
-      withdrawEmissionsResponse.userRequestId,
-    );
-
-    return txSig;
-  }
 }
 
 type ApiErrorPayload = {
@@ -507,6 +397,15 @@ type ApiErrorPayload = {
   timestamp: string;
 };
 
+function handleStatusCode(statusCode: number): void {
+  switch (statusCode) {
+    case 200:
+      break;
+    default:
+      throw new Error(`unexpected status code: ${statusCode}`);
+  }
+}
+
 // Helper function to handle API calls
 async function handleApiCall<T>(
   call: () => Promise<AxiosResponse<T>>,
@@ -540,18 +439,6 @@ function getDummyProvider(): AnchorProvider {
 }
 
 function parseBank(bankJson: any): Bank {
-  let bankEmissions: BankEmissions | null = null;
-  if (bankJson.emissions) {
-    bankEmissions = {
-      emissionsMode: bankJson.emissions.emissionsMode as BankEmissionsMode,
-      emissionsApy: Number(bankJson.emissions.emissionsApy),
-      emissionsMint: new web3.PublicKey(bankJson.emissions.emissionsMint),
-      emissionsTokenPrice: Number(bankJson.emissions.emissionsTokenPrice),
-      emissionsRate: new BN(bankJson.emissions.emissionsRate, "hex"),
-      emissionsRemainingUi: Number(bankJson.emissions.emissionsRemainingUi),
-    };
-  }
-
   return {
     mint: new web3.PublicKey(bankJson.mint),
     key: new web3.PublicKey(bankJson.key),
@@ -565,7 +452,6 @@ function parseBank(bankJson: any): Bank {
     assetMaintWeight: Number(bankJson.assetMaintWeight),
     totalAssetShares: Number(bankJson.totalAssetShares),
     assetShareValue: Number(bankJson.assetShareValue),
-    tokenYieldApy: Number(bankJson.tokenYieldApy),
     liabilityAmount: new BN(bankJson.liabilityAmount, "hex"),
     liabilityAmountUi: Number(bankJson.liabilityAmountUi),
     liabilityInitWeight: Number(bankJson.liabilityInitWeight),
@@ -577,6 +463,5 @@ function parseBank(bankJson: any): Bank {
     depositLimitUi: Number(bankJson.depositLimitUi),
     borrowLimit: new BN(bankJson.borrowLimit, "hex"),
     borrowLimitUi: Number(bankJson.borrowLimitUi),
-    emissions: bankEmissions,
   };
 }