@carrot-protocol/boost-http-client 0.2.16-group-refactor1-dev-50c976e → 0.2.16-token22-dev-158437a

package/src/index.ts

@@ -12,13 +12,25 @@ import {
   WithdrawLeverageResponse,
   UserWallet,
   ClendAccount,
-  Balance,
+  ClendAccountBalance,
   Bank,
   GetGroupResponse,
   ClendAccountEvent,
   GetUserRequest,
   ClendAccountTxSummary,
   UserRequest,
+  UserBalance,
+  ClendAccountAssetLiquidation,
+  GetGroupsResponse,
+  GroupAndBanks,
+  BankEmissions,
+  BankEmissionsMode,
+  WithdrawEmissionsRequest,
+  WithdrawEmissionsResponse,
+  DepositRequest,
+  DepositResponse,
+  WithdrawRequest,
+  WithdrawResponse,
 } from "./types";
 import encode from "bs58";
 
@@ -98,153 +110,207 @@ export class Client {
     return handleApiCall(() => this.http.get(""));
   }
 
-  /**
-   * 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();
-    }
-
+  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.
     const body = await handleApiCall(() =>
       this.http.get(
-        `/user?user=${user.toString()}&getClendAccountSummary=${request.getClendAccountSummary}`,
+        `/user?user=${user.toString()}&groups=${groups.map((g) => g.toString()).join(",")}&getClendAccountSummary=${getClendAccountSummary}`,
       ),
     );
 
+    // Parse the raw string body into a JSON object.
     const jsonRawResponse: any = JSON.parse(body);
 
-    // get tokens still in user wallet
-    const wallet: UserWallet = {
-      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),
-    };
+    // 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),
+    }));
 
-    // 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),
+    const wallet: UserWallet = {
+      balances: walletBalances,
     };
 
-    // 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,
+    // 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),
         };
-        txSummary.input = input;
-      }
 
-      // get events for each summary
-      for (const event of s.events) {
-        let closeBalance: boolean | null = null;
-        if (event.closeBalance !== null) {
-          closeBalance = Boolean(event.closeBalance);
+        // 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;
+          });
         }
 
-        // 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);
-    }
+        // C. Combine the parsed account and its summary
+        return { clendAccount, summary };
+      },
+    );
 
+    // 3. Return the final, correctly structured response object.
     return {
       wallet,
-      clendAccount,
-      summary,
+      clendAccounts,
     };
   }
+  /**
+   * 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
@@ -257,14 +323,18 @@ export class Client {
     );
 
     const marketJson: any = JSON.parse(body);
-    const banks: Bank[] = [];
-    for (const bankJson of marketJson.banks) {
+    const group: GroupAndBanks = {
+      group: new web3.PublicKey(marketJson.group.group),
+      groupName: marketJson.group.groupName,
+      banks: [],
+    };
+    for (const bankJson of marketJson.group.banks) {
       const bank = parseBank(bankJson);
-      banks.push(bank);
+      group.banks.push(bank);
     }
 
     const response: GetGroupResponse = {
-      banks,
+      group,
     };
 
     return response;
@@ -290,20 +360,80 @@ export class Client {
     return response;
   }
 
+  async deposit(
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey | null,
+    inputTokenMint: web3.PublicKey,
+    uiAmount: number,
+  ): Promise<string> {
+    const req: DepositRequest = {
+      owner: this.address(),
+      clendGroup,
+      clendAccount,
+      inputTokenMint,
+      depositAmountUi: uiAmount,
+    };
+
+    const body = await handleApiCall(() =>
+      this.http.post("deposit", JSON.stringify(req)),
+    );
+
+    const depositResponse: DepositResponse = JSON.parse(body);
+
+    const txSig = await this.send(
+      depositResponse.unsignedBase64Tx,
+      depositResponse.userRequestId,
+    );
+
+    return txSig;
+  }
+
+  async withdraw(
+    clendAccount: web3.PublicKey,
+    outputTokenMint: web3.PublicKey,
+    uiAmount: number,
+    withdrawAll: boolean,
+  ): Promise<string> {
+    const req: WithdrawRequest = {
+      clendAccount,
+      outputTokenMint,
+      withdrawAmountUi: uiAmount,
+      withdrawAll,
+    };
+
+    const body = await handleApiCall(() =>
+      this.http.post("withdraw", JSON.stringify(req)),
+    );
+
+    const withdrawResponse: WithdrawResponse = JSON.parse(body);
+
+    const txSig = await this.send(
+      withdrawResponse.unsignedBase64Tx,
+      withdrawResponse.userRequestId,
+    );
+
+    return txSig;
+  }
+
   /**
    * Deposit collateral and create a leveraged position
    * @param request Deposit leverage request parameters
    * @returns Deposit leverage operation result
    */
   async depositLeverage(
-    inputMint: web3.PublicKey,
-    assetMint: web3.PublicKey,
-    liabilityMint: web3.PublicKey,
+    clendGroup: web3.PublicKey,
+    clendAccount: web3.PublicKey | null,
+    inputTokenMint: web3.PublicKey,
+    assetTokenMint: web3.PublicKey,
+    liabilityTokenMint: web3.PublicKey,
     uiAmount: number,
     leverage: number,
     slippageBps: number,
   ): Promise<string> {
-    if (!inputMint.equals(assetMint) || !inputMint.equals(liabilityMint)) {
+    if (
+      !inputTokenMint.equals(assetTokenMint) &&
+      !inputTokenMint.equals(liabilityTokenMint)
+    ) {
       throw new Error(
         "Input mint must be the same as the asset or liability mint",
       );
@@ -311,9 +441,11 @@ export class Client {
 
     const req: DepositLeverageRequest = {
       owner: this.address(),
-      inputMint,
-      assetMint,
-      liabilityMint,
+      clendGroup,
+      clendAccount,
+      inputTokenMint,
+      assetTokenMint,
+      liabilityTokenMint,
       depositAmountUi: uiAmount,
       leverage,
       slippageBps,
@@ -337,9 +469,17 @@ export class Client {
    * @param request Adjust leverage request parameters
    * @returns Adjust leverage operation result
    */
-  async adjustLeverage(leverage: number, slippageBps: number): Promise<any> {
+  async adjustLeverage(
+    clendAccount: web3.PublicKey,
+    assetTokenMint: web3.PublicKey,
+    liabilityTokenMint: web3.PublicKey,
+    leverage: number,
+    slippageBps: number,
+  ): Promise<string> {
     const req: AdjustLeverageRequest = {
-      owner: this.address(),
+      clendAccount,
+      assetTokenMint,
+      liabilityTokenMint,
       leverage,
       slippageBps,
     };
@@ -363,14 +503,19 @@ export class Client {
    * @returns Withdraw leverage operation result
    */
   async withdrawLeverage(
-    selectedTokenMint: web3.PublicKey,
+    clendAccount: web3.PublicKey,
+    outputTokenMint: web3.PublicKey,
+    assetTokenMint: web3.PublicKey,
+    liabilityTokenMint: web3.PublicKey,
     uiAmount: number,
     slippageBps: number,
     withdrawAll: boolean,
-  ): Promise<any> {
+  ): Promise<string> {
     const req: WithdrawLeverageRequest = {
-      owner: this.address(),
-      selectedTokenMint,
+      clendAccount,
+      outputTokenMint,
+      assetTokenMint,
+      liabilityTokenMint,
       withdrawAmountUi: uiAmount,
       slippageBps,
       withdrawAll,
@@ -388,6 +533,30 @@ 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 = {
@@ -397,15 +566,6 @@ 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>>,
@@ -439,6 +599,18 @@ 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),
@@ -452,6 +624,7 @@ 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),
@@ -463,5 +636,6 @@ function parseBank(bankJson: any): Bank {
     depositLimitUi: Number(bankJson.depositLimitUi),
     borrowLimit: new BN(bankJson.borrowLimit, "hex"),
     borrowLimitUi: Number(bankJson.borrowLimitUi),
+    emissions: bankEmissions,
   };
 }