@carrot-protocol/boost-http-client 0.1.7 → 0.2.0-data-fixes-dev-f1a2e89

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, web3 } from "@coral-xyz/anchor";
-import { DepositLeverageRequest, GetMarketResponse, GetUserResponse, ModifyLeverageRequest, WithdrawLeverageRequest } from "./types";
+import { GetBankResponse, GetUserResponse, AdjustLeverageRequest, GetGroupResponse } from "./types";
 export * from "./types";
 /**
  * HTTP Client for Carrot Boost API
@@ -27,31 +27,33 @@ export declare class Client {
      */
     getUser(user?: web3.PublicKey): Promise<GetUserResponse>;
     /**
-     * Get market details for the carrot boost market
-     * @returns Market details
+     * Get market details
+     * @returns Group Details
      */
-    getMarket(): Promise<GetMarketResponse>;
+    getGroup(): Promise<GetGroupResponse>;
     /**
-     * Create an obligation for the client
-     * @returns Transaction signature
+     * Get bank details
+     * @param addr token mint or bank public key
+     * @param addrType "mint" or "bank"
+     * @returns Bank details
      */
-    createObligation(): Promise<string>;
+    getBank(addr: web3.PublicKey, addrType: "mint" | "bank"): Promise<GetBankResponse>;
     /**
      * Deposit collateral and create a leveraged position
      * @param request Deposit leverage request parameters
      * @returns Deposit leverage operation result
      */
-    depositLeverage(params: DepositLeverageRequest): Promise<string>;
+    depositLeverage(selectedTokenMint: web3.PublicKey, uiAmount: number, leverage: number, slippageBps: number): Promise<string>;
     /**
-     * Modify the leverage of an existing position
-     * @param request Modify leverage request parameters
-     * @returns Modify leverage operation result
+     * Adjust the leverage of an existing position
+     * @param request Adjust leverage request parameters
+     * @returns Adjust leverage operation result
      */
-    modifyLeverage(params: ModifyLeverageRequest): Promise<any>;
+    adjustLeverage(params: AdjustLeverageRequest): Promise<any>;
     /**
      * Withdraw from or close a leveraged position
      * @param request Withdraw leverage request parameters
      * @returns Withdraw leverage operation result
      */
-    withdrawLeverage(params: WithdrawLeverageRequest): Promise<any>;
+    withdrawLeverage(selectedTokenMint: web3.PublicKey, uiAmount: number, slippageBps: number, withdrawAll: boolean): Promise<any>;
 }

package/dist/index.js

@@ -10,28 +10,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
@@ -40,7 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Client = void 0;
-const axios_1 = __importStar(require("axios"));
+const axios_1 = __importDefault(require("axios"));
 const anchor_1 = require("@coral-xyz/anchor");
 const bs58_1 = __importDefault(require("bs58"));
 // Re-export types
@@ -70,7 +48,7 @@ class Client {
         return this.provider.wallet.publicKey;
     }
     // sign and send tx to api for sending to network
-    async send(unsignedBase64Tx, ...signedBase64Txns) {
+    async send(unsignedBase64Tx) {
         // deserialize into tx obj
         const txBytes = Buffer.from(unsignedBase64Tx, "base64");
         const tx = anchor_1.web3.VersionedTransaction.deserialize(new Uint8Array(txBytes));
@@ -81,7 +59,7 @@ class Client {
         const encodedAndSignedTx = Buffer.from(signedTx.serialize()).toString("base64");
         // create request obj
         const sendRequest = {
-            txns: [encodedAndSignedTx, ...signedBase64Txns],
+            txns: [encodedAndSignedTx],
         };
         // send to api
         await handleApiCall(() => this.http.post(`send`, sendRequest));
@@ -106,48 +84,115 @@ class Client {
             user = this.address();
         }
         const body = await handleApiCall(() => this.http.get(`/user?user=${user.toString()}`));
-        const response = JSON.parse(body);
-        return response;
+        const jsonRawResponse = JSON.parse(body);
+        // get tokens still in user wallet
+        const wallet = {
+            usdcBalance: new anchor_1.BN(jsonRawResponse.wallet.usdcBalance, "hex"),
+            usdcBalanceUi: Number(jsonRawResponse.wallet.usdcBalanceUi),
+            jlpBalance: new anchor_1.BN(jsonRawResponse.wallet.jlpBalance, "hex"),
+            jlpBalanceUi: Number(jsonRawResponse.wallet.jlpBalanceUi),
+            solBalance: new anchor_1.BN(jsonRawResponse.wallet.solBalance, "hex"),
+            solBalanceUi: Number(jsonRawResponse.wallet.solBalanceUi),
+        };
+        // if no clend account, return undefined for clend
+        if (!jsonRawResponse.clendAccount) {
+            return {
+                wallet,
+                clendAccount: undefined,
+            };
+        }
+        // parse lending account balances
+        const balances = [];
+        for (const b of jsonRawResponse.clendAccount.balances) {
+            balances.push({
+                mint: new anchor_1.web3.PublicKey(b.mint),
+                bank: new anchor_1.web3.PublicKey(b.bank),
+                assetBalance: new anchor_1.BN(b.assetBalance, "hex"),
+                assetBalanceUi: Number(b.assetBalanceUi),
+                assetValue: Number(b.assetValue),
+                liabilityBalance: new anchor_1.BN(b.liabilityBalance, "hex"),
+                liabilityBalanceUi: Number(b.liabilityBalanceUi),
+                liabilityValue: Number(b.liabilityValue),
+                price: Number(b.price),
+            });
+        }
+        // create clend account
+        const 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),
+        };
+        return {
+            wallet,
+            clendAccount,
+        };
     }
     /**
-     * Get market details for the carrot boost market
-     * @returns Market details
+     * Get market details
+     * @returns Group Details
      */
-    async getMarket() {
-        const body = await handleApiCall(() => this.http.get(`market`));
-        const response = JSON.parse(body);
+    async getGroup() {
+        const body = await handleApiCall(() => this.http.get(`/group`));
+        const marketJson = JSON.parse(body);
+        const banks = [];
+        for (const bankJson of marketJson.banks) {
+            const bank = parseBank(bankJson);
+            banks.push(bank);
+        }
+        const response = {
+            banks,
+        };
         return response;
     }
     /**
-     * Create an obligation for the client
-     * @returns Transaction signature
+     * Get bank details
+     * @param addr token mint or bank public key
+     * @param addrType "mint" or "bank"
+     * @returns Bank details
      */
-    async createObligation() {
-        const body = await handleApiCall(() => this.http.post("createObligation", JSON.stringify({ owner: this.address() })));
-        const createObligationResponse = JSON.parse(body);
-        const txSig = await this.send(createObligationResponse.unsignedBase64Tx);
-        return txSig;
+    async getBank(addr, addrType) {
+        const body = await handleApiCall(() => this.http.get(`/bank?${addrType}=${addr.toString()}`));
+        const bankJson = JSON.parse(body);
+        const bank = parseBank(bankJson.bank);
+        const response = {
+            bank,
+        };
+        return response;
     }
     /**
      * Deposit collateral and create a leveraged position
      * @param request Deposit leverage request parameters
      * @returns Deposit leverage operation result
      */
-    async depositLeverage(params) {
-        const body = await handleApiCall(() => this.http.post("leverage/deposit", JSON.stringify(params)));
+    async depositLeverage(selectedTokenMint, uiAmount, leverage, slippageBps) {
+        const req = {
+            owner: this.address(),
+            selectedTokenMint,
+            depositAmountUi: uiAmount,
+            leverage,
+            slippageBps,
+        };
+        const body = await handleApiCall(() => this.http.post("leverage/deposit", JSON.stringify(req)));
         const depositLeverageResponse = JSON.parse(body);
-        const txSig = await this.send(depositLeverageResponse.unsignedBase64Tx, depositLeverageResponse.signedSetBorrowRateBase64Tx);
+        const txSig = await this.send(depositLeverageResponse.unsignedBase64Tx);
         return txSig;
     }
     /**
-     * Modify the leverage of an existing position
-     * @param request Modify leverage request parameters
-     * @returns Modify leverage operation result
+     * Adjust the leverage of an existing position
+     * @param request Adjust leverage request parameters
+     * @returns Adjust leverage operation result
      */
-    async modifyLeverage(params) {
-        const body = await handleApiCall(() => this.http.post("leverage/modify", JSON.stringify(params)));
-        const modifyLeverageResponse = JSON.parse(body);
-        const txSig = await this.send(modifyLeverageResponse.unsignedBase64Tx, modifyLeverageResponse.signedSetBorrowRateBase64Tx);
+    async adjustLeverage(params) {
+        const body = await handleApiCall(() => this.http.post("leverage/adjust", JSON.stringify(params)));
+        const adjustLeverageResponse = JSON.parse(body);
+        const txSig = await this.send(adjustLeverageResponse.unsignedBase64Tx);
         return txSig;
     }
     /**
@@ -155,10 +200,17 @@ class Client {
      * @param request Withdraw leverage request parameters
      * @returns Withdraw leverage operation result
      */
-    async withdrawLeverage(params) {
-        const body = await handleApiCall(() => this.http.post("leverage/withdraw", JSON.stringify(params)));
+    async withdrawLeverage(selectedTokenMint, uiAmount, slippageBps, withdrawAll) {
+        const req = {
+            owner: this.address(),
+            selectedTokenMint,
+            withdrawAmountUi: uiAmount,
+            slippageBps,
+            withdrawAll,
+        };
+        const body = await handleApiCall(() => this.http.post("leverage/withdraw", JSON.stringify(req)));
         const withdrawLeverageResponse = JSON.parse(body);
-        const txSig = await this.send(withdrawLeverageResponse.unsignedBase64Tx, withdrawLeverageResponse.signedSetBorrowRateBase64Tx);
+        const txSig = await this.send(withdrawLeverageResponse.unsignedBase64Tx);
         return txSig;
     }
 }
@@ -172,23 +224,21 @@ function handleStatusCode(statusCode) {
     }
 }
 // Helper function to handle API calls
-async function handleApiCall(apiCall) {
+async function handleApiCall(call) {
     try {
-        const response = await apiCall();
-        handleStatusCode(response.status);
-        return JSON.stringify(response.data);
+        const { data } = await call();
+        return JSON.stringify(data);
     }
-    catch (error) {
-        if (error instanceof axios_1.AxiosError) {
-            const simplifiedError = {
-                status: error.response?.status,
-                message: error.message,
-                url: error.config?.url,
-            };
-            console.error(simplifiedError);
-            throw new Error(JSON.stringify(simplifiedError));
+    catch (e) {
+        if (axios_1.default.isAxiosError(e)) {
+            const res = e.response;
+            if (res && typeof res.data === "object") {
+                const payload = res.data;
+                throw new Error(`${payload.error}${payload.details ? ` ${payload.details}` : ""}`);
+            }
+            throw new Error(`${e.message}`);
         }
-        throw error;
+        throw e;
     }
 }
 function getDummyProvider() {
@@ -196,3 +246,18 @@ function getDummyProvider() {
         skipPreflight: true,
     });
 }
+function parseBank(bankJson) {
+    return {
+        mint: new anchor_1.web3.PublicKey(bankJson.mint),
+        key: new anchor_1.web3.PublicKey(bankJson.key),
+        group: new anchor_1.web3.PublicKey(bankJson.group),
+        supplyApy: Number(bankJson.supplyApy),
+        borrowApy: Number(bankJson.borrowApy),
+        utilizationRate: Number(bankJson.utilizationRate),
+        assetAmount: new anchor_1.BN(bankJson.assetAmount, "hex"),
+        assetAmountUi: Number(bankJson.assetAmountUi),
+        liabilityAmount: new anchor_1.BN(bankJson.liabilityAmount, "hex"),
+        liabilityAmountUi: Number(bankJson.liabilityAmountUi),
+        price: Number(bankJson.price),
+    };
+}

package/dist/types.d.ts

@@ -1,45 +1,36 @@
 import { BN, web3 } from "@coral-xyz/anchor";
-import Decimal from "decimal.js";
 export interface SendRequest {
     txns: string[];
 }
-export interface CreateObligationRequest {
-    owner: web3.PublicKey;
-}
-export interface CreateObligationResponse {
-    unsignedBase64Tx: string;
-}
 /**
  * Request to deposit collateral and create a leveraged position
  */
 export interface DepositLeverageRequest {
     owner: web3.PublicKey;
     selectedTokenMint: web3.PublicKey;
-    depositAmount: Decimal;
+    depositAmountUi: number;
     leverage: number;
-    slippagePct: number;
+    slippageBps: number;
 }
 /**
  * Response for deposit leverage operation
  */
 export interface DepositLeverageResponse {
     unsignedBase64Tx: string;
-    signedSetBorrowRateBase64Tx: string;
 }
 /**
- * Request to modify the leverage of an existing position
+ * Request to adjust the leverage of an existing position
  */
-export interface ModifyLeverageRequest {
+export interface AdjustLeverageRequest {
     owner: web3.PublicKey;
     leverage: number;
-    slippagePct: number;
+    slippageBps: number;
 }
 /**
- * Response for modify leverage operation
+ * Response for adjust leverage operation
  */
-export interface ModifyLeverageResponse {
+export interface AdjustLeverageResponse {
     unsignedBase64Tx: string;
-    signedSetBorrowRateBase64Tx: string;
 }
 /**
  * Request to withdraw from a leveraged position
@@ -47,41 +38,67 @@ export interface ModifyLeverageResponse {
 export interface WithdrawLeverageRequest {
     owner: web3.PublicKey;
     selectedTokenMint: web3.PublicKey;
-    withdrawAmount: Decimal;
-    slippagePct: number;
-    closePosition: boolean;
+    withdrawAmountUi: number;
+    slippageBps: number;
+    withdrawAll: boolean;
 }
 /**
  * Response for withdraw leverage operation
  */
 export interface WithdrawLeverageResponse {
     unsignedBase64Tx: string;
-    signedSetBorrowRateBase64Tx: string;
+}
+export interface GetGroupResponse {
+    banks: Bank[];
 }
 export interface GetUserResponse {
-    netValue: number;
-    pnl: number;
-    netAPY: number;
-    leverage: number;
-    totalCollateral: number;
-    totalDebt: number;
-    ltv: number;
-    liquidationLtv: number;
+    wallet: UserWallet;
+    clendAccount: ClendAccount | undefined;
+}
+export interface UserWallet {
     usdcBalance: BN;
     usdcBalanceUi: number;
     jlpBalance: BN;
     jlpBalanceUi: number;
     solBalance: BN;
     solBalanceUi: number;
-    obligationCreated: boolean;
 }
-export interface GetMarketResponse {
-    totalBorrowTVL: number;
-    totalSupplyTVL: number;
-    usdcSupplyApy: number;
-    usdcBorrowApy: number;
-    usdcSupplyAmount: number;
-    usdcBorrowAmount: number;
-    usdcPrice: number;
-    jlpPrice: number;
+export interface ClendAccount {
+    balances: Balance[];
+    netValue: number;
+    netApy: number;
+    pnl: number;
+    totalAssetValue: number;
+    totalLiabilityValue: number;
+    healthFactorNotional: number;
+    healthFactorRiskAdjusted: number;
+    notionalLeverage: number;
+    riskAdjustedLeverage: number;
+}
+export interface Balance {
+    mint: web3.PublicKey;
+    bank: web3.PublicKey;
+    assetBalance: BN;
+    assetBalanceUi: number;
+    assetValue: number;
+    liabilityBalance: BN;
+    liabilityBalanceUi: number;
+    liabilityValue: number;
+    price: number;
+}
+export interface GetBankResponse {
+    bank: Bank;
+}
+export interface Bank {
+    group: web3.PublicKey;
+    key: web3.PublicKey;
+    mint: web3.PublicKey;
+    supplyApy: number;
+    borrowApy: number;
+    utilizationRate: number;
+    assetAmount: BN;
+    assetAmountUi: number;
+    liabilityAmount: BN;
+    liabilityAmountUi: number;
+    price: number;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carrot-protocol/boost-http-client",
-  "version": "0.1.7",
+  "version": "0.2.0-data-fixes-dev-f1a2e89",
   "description": "HTTP client for Carrot Boost API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,16 +1,20 @@
 import axios, { AxiosInstance, AxiosError, AxiosResponse } from "axios";
-import { AnchorProvider, Wallet, web3 } from "@coral-xyz/anchor";
+import { AnchorProvider, BN, Wallet, web3 } from "@coral-xyz/anchor";
 import {
-  CreateObligationResponse,
   DepositLeverageRequest,
   DepositLeverageResponse,
-  GetMarketResponse,
+  GetBankResponse,
   GetUserResponse,
-  ModifyLeverageRequest,
-  ModifyLeverageResponse,
+  AdjustLeverageRequest,
+  AdjustLeverageResponse,
   SendRequest,
   WithdrawLeverageRequest,
   WithdrawLeverageResponse,
+  UserWallet,
+  ClendAccount,
+  Balance,
+  Bank,
+  GetGroupResponse,
 } from "./types";
 import encode from "bs58";
 
@@ -48,10 +52,7 @@ export class Client {
   }
 
   // sign and send tx to api for sending to network
-  private async send(
-    unsignedBase64Tx: string,
-    ...signedBase64Txns: string[]
-  ): Promise<string> {
+  private async send(unsignedBase64Tx: string): Promise<string> {
     // deserialize into tx obj
     const txBytes = Buffer.from(unsignedBase64Tx, "base64");
     const tx = web3.VersionedTransaction.deserialize(new Uint8Array(txBytes));
@@ -67,7 +68,7 @@ export class Client {
 
     // create request obj
     const sendRequest: SendRequest = {
-      txns: [encodedAndSignedTx, ...signedBase64Txns],
+      txns: [encodedAndSignedTx],
     };
 
     // send to api
@@ -100,40 +101,113 @@ export class Client {
       this.http.get(`/user?user=${user.toString()}`),
     );
 
-    const response: GetUserResponse = JSON.parse(body);
+    const jsonRawResponse: any = JSON.parse(body);
 
-    return response;
+    // 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),
+    };
+
+    // if no clend account, return undefined for clend
+    if (!jsonRawResponse.clendAccount) {
+      return {
+        wallet,
+        clendAccount: undefined,
+      };
+    }
+
+    // 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,
+      ),
+    };
+
+    return {
+      wallet,
+      clendAccount,
+    };
   }
 
   /**
-   * Get market details for the carrot boost market
-   * @returns Market details
+   * Get market details
+   * @returns Group Details
    */
-  async getMarket(): Promise<GetMarketResponse> {
-    const body = await handleApiCall(() => this.http.get(`market`));
+  async getGroup(): Promise<GetGroupResponse> {
+    const body = await handleApiCall(() => this.http.get(`/group`));
+
+    const marketJson: any = JSON.parse(body);
+    const banks: Bank[] = [];
+    for (const bankJson of marketJson.banks) {
+      const bank = parseBank(bankJson);
+      banks.push(bank);
+    }
 
-    const response: GetMarketResponse = JSON.parse(body);
+    const response: GetGroupResponse = {
+      banks,
+    };
 
     return response;
   }
 
   /**
-   * Create an obligation for the client
-   * @returns Transaction signature
+   * Get bank details
+   * @param addr token mint or bank public key
+   * @param addrType "mint" or "bank"
+   * @returns Bank details
    */
-  async createObligation(): Promise<string> {
+  async getBank(
+    addr: web3.PublicKey,
+    addrType: "mint" | "bank",
+  ): Promise<GetBankResponse> {
     const body = await handleApiCall(() =>
-      this.http.post(
-        "createObligation",
-        JSON.stringify({ owner: this.address() }),
-      ),
+      this.http.get(`/bank?${addrType}=${addr.toString()}`),
     );
 
-    const createObligationResponse: CreateObligationResponse = JSON.parse(body);
+    const bankJson: any = JSON.parse(body);
+    const bank = parseBank(bankJson.bank);
 
-    const txSig = await this.send(createObligationResponse.unsignedBase64Tx);
+    const response: GetBankResponse = {
+      bank,
+    };
 
-    return txSig;
+    return response;
   }
 
   /**
@@ -141,37 +215,43 @@ export class Client {
    * @param request Deposit leverage request parameters
    * @returns Deposit leverage operation result
    */
-  async depositLeverage(params: DepositLeverageRequest): Promise<string> {
+  async depositLeverage(
+    selectedTokenMint: web3.PublicKey,
+    uiAmount: number,
+    leverage: number,
+    slippageBps: number,
+  ): Promise<string> {
+    const req: DepositLeverageRequest = {
+      owner: this.address(),
+      selectedTokenMint,
+      depositAmountUi: uiAmount,
+      leverage,
+      slippageBps,
+    };
     const body = await handleApiCall(() =>
-      this.http.post("leverage/deposit", JSON.stringify(params)),
+      this.http.post("leverage/deposit", JSON.stringify(req)),
     );
 
     const depositLeverageResponse: DepositLeverageResponse = JSON.parse(body);
 
-    const txSig = await this.send(
-      depositLeverageResponse.unsignedBase64Tx,
-      depositLeverageResponse.signedSetBorrowRateBase64Tx,
-    );
+    const txSig = await this.send(depositLeverageResponse.unsignedBase64Tx);
 
     return txSig;
   }
 
   /**
-   * Modify the leverage of an existing position
-   * @param request Modify leverage request parameters
-   * @returns Modify leverage operation result
+   * Adjust the leverage of an existing position
+   * @param request Adjust leverage request parameters
+   * @returns Adjust leverage operation result
    */
-  async modifyLeverage(params: ModifyLeverageRequest): Promise<any> {
+  async adjustLeverage(params: AdjustLeverageRequest): Promise<any> {
     const body = await handleApiCall(() =>
-      this.http.post("leverage/modify", JSON.stringify(params)),
+      this.http.post("leverage/adjust", JSON.stringify(params)),
     );
 
-    const modifyLeverageResponse: ModifyLeverageResponse = JSON.parse(body);
+    const adjustLeverageResponse: AdjustLeverageResponse = JSON.parse(body);
 
-    const txSig = await this.send(
-      modifyLeverageResponse.unsignedBase64Tx,
-      modifyLeverageResponse.signedSetBorrowRateBase64Tx,
-    );
+    const txSig = await this.send(adjustLeverageResponse.unsignedBase64Tx);
 
     return txSig;
   }
@@ -181,22 +261,38 @@ export class Client {
    * @param request Withdraw leverage request parameters
    * @returns Withdraw leverage operation result
    */
-  async withdrawLeverage(params: WithdrawLeverageRequest): Promise<any> {
+  async withdrawLeverage(
+    selectedTokenMint: web3.PublicKey,
+    uiAmount: number,
+    slippageBps: number,
+    withdrawAll: boolean,
+  ): Promise<any> {
+    const req: WithdrawLeverageRequest = {
+      owner: this.address(),
+      selectedTokenMint,
+      withdrawAmountUi: uiAmount,
+      slippageBps,
+      withdrawAll,
+    };
     const body = await handleApiCall(() =>
-      this.http.post("leverage/withdraw", JSON.stringify(params)),
+      this.http.post("leverage/withdraw", JSON.stringify(req)),
     );
 
     const withdrawLeverageResponse: WithdrawLeverageResponse = JSON.parse(body);
 
-    const txSig = await this.send(
-      withdrawLeverageResponse.unsignedBase64Tx,
-      withdrawLeverageResponse.signedSetBorrowRateBase64Tx,
-    );
+    const txSig = await this.send(withdrawLeverageResponse.unsignedBase64Tx);
 
     return txSig;
   }
 }
 
+type ApiErrorPayload = {
+  error: string;
+  details?: unknown;
+  path: string;
+  timestamp: string;
+};
+
 function handleStatusCode(statusCode: number): void {
   switch (statusCode) {
     case 200:
@@ -208,23 +304,23 @@ function handleStatusCode(statusCode: number): void {
 
 // Helper function to handle API calls
 async function handleApiCall<T>(
-  apiCall: () => Promise<AxiosResponse<T>>,
-): Promise<any> {
+  call: () => Promise<AxiosResponse<T>>,
+): Promise<string> {
   try {
-    const response = await apiCall();
-    handleStatusCode(response.status);
-    return JSON.stringify(response.data);
-  } catch (error) {
-    if (error instanceof AxiosError) {
-      const simplifiedError = {
-        status: error.response?.status,
-        message: error.message,
-        url: error.config?.url,
-      };
-      console.error(simplifiedError);
-      throw new Error(JSON.stringify(simplifiedError));
+    const { data } = await call();
+    return JSON.stringify(data);
+  } catch (e) {
+    if (axios.isAxiosError(e)) {
+      const res = e.response;
+      if (res && typeof res.data === "object") {
+        const payload = res.data as ApiErrorPayload;
+        throw new Error(
+          `${payload.error}${payload.details ? ` ${payload.details}` : ""}`,
+        );
+      }
+      throw new Error(`${e.message}`);
     }
-    throw error;
+    throw e;
   }
 }
 
@@ -237,3 +333,19 @@ function getDummyProvider(): AnchorProvider {
     },
   );
 }
+
+function parseBank(bankJson: any): Bank {
+  return {
+    mint: new web3.PublicKey(bankJson.mint),
+    key: new web3.PublicKey(bankJson.key),
+    group: new web3.PublicKey(bankJson.group),
+    supplyApy: Number(bankJson.supplyApy),
+    borrowApy: Number(bankJson.borrowApy),
+    utilizationRate: Number(bankJson.utilizationRate),
+    assetAmount: new BN(bankJson.assetAmount, "hex"),
+    assetAmountUi: Number(bankJson.assetAmountUi),
+    liabilityAmount: new BN(bankJson.liabilityAmount, "hex"),
+    liabilityAmountUi: Number(bankJson.liabilityAmountUi),
+    price: Number(bankJson.price),
+  };
+}

package/src/types.ts

@@ -6,23 +6,15 @@ export interface SendRequest {
   txns: string[];
 }
 
-export interface CreateObligationRequest {
-  owner: web3.PublicKey;
-}
-
-export interface CreateObligationResponse {
-  unsignedBase64Tx: string;
-}
-
 /**
  * Request to deposit collateral and create a leveraged position
  */
 export interface DepositLeverageRequest {
   owner: web3.PublicKey;
   selectedTokenMint: web3.PublicKey;
-  depositAmount: Decimal;
+  depositAmountUi: number;
   leverage: number;
-  slippagePct: number;
+  slippageBps: number;
 }
 
 /**
@@ -30,24 +22,22 @@ export interface DepositLeverageRequest {
  */
 export interface DepositLeverageResponse {
   unsignedBase64Tx: string;
-  signedSetBorrowRateBase64Tx: string;
 }
 
 /**
- * Request to modify the leverage of an existing position
+ * Request to adjust the leverage of an existing position
  */
-export interface ModifyLeverageRequest {
+export interface AdjustLeverageRequest {
   owner: web3.PublicKey;
   leverage: number;
-  slippagePct: number;
+  slippageBps: number;
 }
 
 /**
- * Response for modify leverage operation
+ * Response for adjust leverage operation
  */
-export interface ModifyLeverageResponse {
+export interface AdjustLeverageResponse {
   unsignedBase64Tx: string;
-  signedSetBorrowRateBase64Tx: string;
 }
 
 /**
@@ -56,9 +46,9 @@ export interface ModifyLeverageResponse {
 export interface WithdrawLeverageRequest {
   owner: web3.PublicKey;
   selectedTokenMint: web3.PublicKey;
-  withdrawAmount: Decimal;
-  slippagePct: number;
-  closePosition: boolean;
+  withdrawAmountUi: number;
+  slippageBps: number;
+  withdrawAll: boolean;
 }
 
 /**
@@ -66,34 +56,65 @@ export interface WithdrawLeverageRequest {
  */
 export interface WithdrawLeverageResponse {
   unsignedBase64Tx: string;
-  signedSetBorrowRateBase64Tx: string;
+}
+
+export interface GetGroupResponse {
+  banks: Bank[];
 }
 
 export interface GetUserResponse {
-  netValue: number;
-  pnl: number;
-  netAPY: number;
-  leverage: number;
-  totalCollateral: number;
-  totalDebt: number;
-  ltv: number;
-  liquidationLtv: number;
+  wallet: UserWallet;
+  clendAccount: ClendAccount | undefined;
+}
+
+export interface UserWallet {
   usdcBalance: BN;
   usdcBalanceUi: number;
   jlpBalance: BN;
   jlpBalanceUi: number;
   solBalance: BN;
   solBalanceUi: number;
-  obligationCreated: boolean;
 }
 
-export interface GetMarketResponse {
-  totalBorrowTVL: number;
-  totalSupplyTVL: number;
-  usdcSupplyApy: number;
-  usdcBorrowApy: number;
-  usdcSupplyAmount: number;
-  usdcBorrowAmount: number;
-  usdcPrice: number;
-  jlpPrice: number;
+export interface ClendAccount {
+  balances: Balance[];
+  netValue: number;
+  netApy: number;
+  pnl: number;
+  totalAssetValue: number;
+  totalLiabilityValue: number;
+  healthFactorNotional: number;
+  healthFactorRiskAdjusted: number;
+  notionalLeverage: number;
+  riskAdjustedLeverage: number;
+}
+
+export interface Balance {
+  mint: web3.PublicKey;
+  bank: web3.PublicKey;
+  assetBalance: BN;
+  assetBalanceUi: number;
+  assetValue: number;
+  liabilityBalance: BN;
+  liabilityBalanceUi: number;
+  liabilityValue: number;
+  price: number;
+}
+
+export interface GetBankResponse {
+  bank: Bank;
+}
+
+export interface Bank {
+  group: web3.PublicKey;
+  key: web3.PublicKey;
+  mint: web3.PublicKey;
+  supplyApy: number;
+  borrowApy: number;
+  utilizationRate: number;
+  assetAmount: BN;
+  assetAmountUi: number;
+  liabilityAmount: BN;
+  liabilityAmountUi: number;
+  price: number;
 }