@carrot-protocol/boost-http-client 0.3.1-feat-get-ohlc-endpoint-dev-43df047 → 0.3.1

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, web3 } from "@coral-xyz/anchor";
-import { GetBankResponse, GetUserResponse, GetGroupResponse, GetGroupsResponse, GetVaultOHLCResponse, GetVaultOHLCRequest } from "./types";
+import { GetBankResponse, GetUserResponse, GetGroupResponse, GetGroupsResponse, GetAccountResponse, GetAccountRequest } from "./types";
 export * from "./types";
 export * from "./utils";
 export * as Common from "@carrot-protocol/clend-common";
@@ -10,11 +10,12 @@ export declare class Client {
     private readonly baseUrl;
     private readonly http;
     private readonly provider;
+    private readonly dryRun;
     /**
      * Create a new Carrot Boost API client
      * @param baseUrl Base URL for the API
      */
-    constructor(baseUrl: string, provider?: AnchorProvider);
+    constructor(baseUrl: string, provider?: AnchorProvider, dryRun?: boolean);
     address(): web3.PublicKey;
     private send;
     /**
@@ -22,6 +23,15 @@ export declare class Client {
      * @returns Index details
      */
     index(): Promise<any>;
+    /**
+     * Fetch and parse a single clend account by pubkey
+     */
+    getAccount(account: GetAccountRequest["account"], getClendAccountSummary: GetAccountRequest["getClendAccountSummary"]): Promise<GetAccountResponse>;
+    /**
+     * Helper to parse a clend account summary array from API response
+     */
+    private parseClendAccountSummary;
+    private parseClendAccountWithSummary;
     getUser(user: web3.PublicKey, groups: web3.PublicKey[], getClendAccountSummary: boolean): Promise<GetUserResponse>;
     /**
      * Get all groups
@@ -41,12 +51,8 @@ export declare class Client {
      * @returns Bank details
      */
     getBank(bankAddress: web3.PublicKey): Promise<GetBankResponse>;
-    /**
-     * Get vault OHLC graph data
-     * @param vaultAddress vault public key
-     * @returns OHLC graph data
-     */
-    getVaultOHLC(vaultAddress: GetVaultOHLCRequest["vault"]): Promise<GetVaultOHLCResponse>;
+    deposit(clendGroup: web3.PublicKey, clendAccount: web3.PublicKey | null, inputTokenMint: web3.PublicKey, uiAmount: number): Promise<string>;
+    withdraw(clendAccount: web3.PublicKey, outputTokenMint: web3.PublicKey, uiAmount: number, withdrawAll: boolean): Promise<string>;
     /**
      * Deposit collateral and create a leveraged position
      * @param request Deposit leverage request parameters

package/dist/index.js

@@ -56,7 +56,7 @@ class Client {
      * Create a new Carrot Boost API client
      * @param baseUrl Base URL for the API
      */
-    constructor(baseUrl, provider) {
+    constructor(baseUrl, provider, dryRun) {
         this.baseUrl = new URL(baseUrl).toString();
         this.http = axios_1.default.create({
             baseURL: this.baseUrl,
@@ -67,6 +67,7 @@ class Client {
         if (!provider) {
             provider = getDummyProvider();
         }
+        this.dryRun = dryRun ?? false;
         this.provider = provider;
     }
     address() {
@@ -74,6 +75,10 @@ class Client {
     }
     // sign and send tx to api for sending to network
     async send(unsignedBase64Tx, userRequestId) {
+        if (this.dryRun) {
+            // for debugging purposes only
+            console.log("unsigedBase64Tx", unsignedBase64Tx);
+        }
         // deserialize into tx obj
         const txBytes = Buffer.from(unsignedBase64Tx, "base64");
         const tx = anchor_1.web3.VersionedTransaction.deserialize(new Uint8Array(txBytes));
@@ -88,7 +93,12 @@ class Client {
             txns: [encodedAndSignedTx],
         };
         // send to api
-        await handleApiCall(() => this.http.post(`send`, sendRequest));
+        if (!this.dryRun) {
+            await handleApiCall(() => this.http.post(`send`, sendRequest));
+        }
+        else {
+            console.warn("dry run enabled, did not send tx");
+        }
         // return txsig
         return bs58_1.default.encode(txSig);
     }
@@ -99,6 +109,120 @@ class Client {
     async index() {
         return handleApiCall(() => this.http.get(""));
     }
+    /**
+     * Fetch and parse a single clend account by pubkey
+     */
+    async getAccount(account, getClendAccountSummary) {
+        const body = await handleApiCall(() => this.http.get(`/account?account=${account.toString()}&getClendAccountSummary=${getClendAccountSummary}`));
+        const jsonRawResponse = JSON.parse(body);
+        return this.parseClendAccountWithSummary(jsonRawResponse, getClendAccountSummary);
+    }
+    /**
+     * Helper to parse a clend account summary array from API response
+     */
+    parseClendAccountSummary(summaryArr) {
+        return summaryArr.map((s) => {
+            let input = undefined;
+            if (s.input) {
+                input = {
+                    apiPath: s.input.apiPath,
+                    selectedTokenMint: s.input.selectedTokenMint
+                        ? new anchor_1.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 = (s.events || []).map((event) => {
+                let closeBalance = null;
+                if (event.closeBalance !== null && event.closeBalance !== undefined) {
+                    closeBalance = Boolean(event.closeBalance);
+                }
+                return {
+                    eventIndex: event.eventIndex,
+                    eventName: event.eventName,
+                    bank: event.bank ? new anchor_1.web3.PublicKey(event.bank) : null,
+                    mint: event.mint ? new anchor_1.web3.PublicKey(event.mint) : null,
+                    amount: event.amount ? new anchor_1.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 = {
+                txSig: s.txSig,
+                time: s.time,
+                clendAccount: new anchor_1.web3.PublicKey(s.clendAccount),
+                clendAccountAuthority: new anchor_1.web3.PublicKey(s.clendAccountAuthority),
+                clendGroup: new anchor_1.web3.PublicKey(s.clendGroup),
+                action: s.action,
+                input,
+                events,
+            };
+            return txSummary;
+        });
+    }
+    parseClendAccountWithSummary(accountData, getClendAccountSummary) {
+        // A. Parse the main ClendAccount object
+        const rawClendAccount = accountData.clendAccount;
+        const clendAccountBalances = (rawClendAccount.balances || []).map((b) => {
+            const liquidation = b.liquidation
+                ? {
+                    price: Number(b.liquidation.price),
+                    changePercentage: Number(b.liquidation.changePercentage),
+                }
+                : null;
+            const emissionsOutstandingAndUnclaimed = new anchor_1.BN(b.emissionsOutstandingAndUnclaimed, "hex");
+            return {
+                mint: new anchor_1.web3.PublicKey(b.mint),
+                bank: new anchor_1.web3.PublicKey(b.bank),
+                tokenYieldApy: Number(b.tokenYieldApy),
+                assetBalance: new anchor_1.BN(b.assetBalance, "hex"),
+                assetBalanceUi: Number(b.assetBalanceUi),
+                assetValue: Number(b.assetValue),
+                assetEmissionsApy: Number(b.assetEmissionsApy),
+                liabilityBalance: new anchor_1.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 = {
+            key: new anchor_1.web3.PublicKey(rawClendAccount.key),
+            group: new anchor_1.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),
+        };
+        // B. Parse the associated Summary array for the account
+        let summary = [];
+        if (getClendAccountSummary && accountData.summary) {
+            summary = this.parseClendAccountSummary(accountData.summary);
+        }
+        // C. Combine the parsed account and its summary
+        return { clendAccount, summary };
+    }
     async getUser(user, groups, getClendAccountSummary) {
         // Make the API call to fetch the raw user data as a string.
         const body = await handleApiCall(() => this.http.get(`/user?user=${user.toString()}&groups=${groups.map((g) => g.toString()).join(",")}&getClendAccountSummary=${getClendAccountSummary}`));
@@ -117,112 +241,7 @@ class Client {
         // 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) => {
-            // A. Parse the main ClendAccount object
-            const rawClendAccount = accountData.clendAccount;
-            const clendAccountBalances = (rawClendAccount.balances || []).map((b) => {
-                const liquidation = b.liquidation
-                    ? {
-                        price: Number(b.liquidation.price),
-                        changePercentage: Number(b.liquidation.changePercentage),
-                    }
-                    : null;
-                const emissionsOutstandingAndUnclaimed = new anchor_1.BN(b.emissionsOutstandingAndUnclaimed, "hex");
-                return {
-                    mint: new anchor_1.web3.PublicKey(b.mint),
-                    bank: new anchor_1.web3.PublicKey(b.bank),
-                    tokenYieldApy: Number(b.tokenYieldApy),
-                    assetBalance: new anchor_1.BN(b.assetBalance, "hex"),
-                    assetBalanceUi: Number(b.assetBalanceUi),
-                    assetValue: Number(b.assetValue),
-                    assetEmissionsApy: Number(b.assetEmissionsApy),
-                    liabilityBalance: new anchor_1.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 = {
-                key: new anchor_1.web3.PublicKey(rawClendAccount.key),
-                group: new anchor_1.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),
-            };
-            // B. Parse the associated Summary array for the account
-            let summary = [];
-            if (getClendAccountSummary && accountData.summary) {
-                summary = accountData.summary.map((s) => {
-                    let input = undefined;
-                    if (s.input) {
-                        input = {
-                            apiPath: s.input.apiPath,
-                            selectedTokenMint: s.input.selectedTokenMint
-                                ? new anchor_1.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 = (s.events || []).map((event) => {
-                        let closeBalance = 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 anchor_1.web3.PublicKey(event.bank) : null,
-                            mint: event.mint ? new anchor_1.web3.PublicKey(event.mint) : null,
-                            amount: event.amount ? new anchor_1.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 = {
-                        txSig: s.txSig,
-                        time: s.time,
-                        clendAccount: new anchor_1.web3.PublicKey(s.clendAccount),
-                        clendAccountAuthority: new anchor_1.web3.PublicKey(s.clendAccountAuthority),
-                        clendGroup: new anchor_1.web3.PublicKey(s.clendGroup),
-                        action: s.action,
-                        input,
-                        events,
-                    };
-                    return txSummary;
-                });
-            }
-            // C. Combine the parsed account and its summary
-            return { clendAccount, summary };
-        });
+        const clendAccounts = (jsonRawResponse.clendAccounts || []).map((accountData) => this.parseClendAccountWithSummary(accountData, getClendAccountSummary));
         // 3. Return the final, correctly structured response object.
         return {
             wallet,
@@ -289,17 +308,30 @@ class Client {
         };
         return response;
     }
-    /**
-     * Get vault OHLC graph data
-     * @param vaultAddress vault public key
-     * @returns OHLC graph data
-     */
-    async getVaultOHLC(vaultAddress) {
-        const body = await handleApiCall(() => this.http.get(`/vaultOhlc?vault=${vaultAddress.toString()}`));
-        const response = {
-            data: JSON.parse(body),
+    async deposit(clendGroup, clendAccount, inputTokenMint, uiAmount) {
+        const req = {
+            owner: this.address(),
+            clendGroup,
+            clendAccount,
+            inputTokenMint,
+            depositAmountUi: uiAmount,
         };
-        return response;
+        const body = await handleApiCall(() => this.http.post("deposit", JSON.stringify(req)));
+        const depositResponse = JSON.parse(body);
+        const txSig = await this.send(depositResponse.unsignedBase64Tx, depositResponse.userRequestId);
+        return txSig;
+    }
+    async withdraw(clendAccount, outputTokenMint, uiAmount, withdrawAll) {
+        const req = {
+            clendAccount,
+            outputTokenMint,
+            withdrawAmountUi: uiAmount,
+            withdrawAll,
+        };
+        const body = await handleApiCall(() => this.http.post("withdraw", JSON.stringify(req)));
+        const withdrawResponse = JSON.parse(body);
+        const txSig = await this.send(withdrawResponse.unsignedBase64Tx, withdrawResponse.userRequestId);
+        return txSig;
     }
     /**
      * Deposit collateral and create a leveraged position

package/dist/types.d.ts

@@ -3,6 +3,33 @@ export interface SendRequest {
     userRequestId: string;
     txns: string[];
 }
+/**
+ * Request to deposit collateral
+ */
+export interface DepositRequest {
+    owner: web3.PublicKey;
+    clendGroup: web3.PublicKey;
+    clendAccount: web3.PublicKey | null;
+    inputTokenMint: web3.PublicKey;
+    depositAmountUi: number;
+}
+export interface DepositResponse {
+    userRequestId: string;
+    unsignedBase64Tx: string;
+}
+/**
+ * Request to withdraw collateral
+ */
+export interface WithdrawRequest {
+    clendAccount: web3.PublicKey;
+    outputTokenMint: web3.PublicKey;
+    withdrawAmountUi: number;
+    withdrawAll: boolean;
+}
+export interface WithdrawResponse {
+    userRequestId: string;
+    unsignedBase64Tx: string;
+}
 /**
  * Request to deposit collateral and create a leveraged position
  */
@@ -84,6 +111,14 @@ export interface GroupAndBanks {
     groupName: string;
     banks: Bank[];
 }
+export interface GetAccountRequest {
+    account: web3.PublicKey;
+    getClendAccountSummary: boolean;
+}
+export interface GetAccountResponse {
+    clendAccount: ClendAccount;
+    summary: ClendAccountTxSummary[];
+}
 export interface GetUserRequest {
     groups: web3.PublicKey[];
     user: web3.PublicKey;
@@ -96,19 +131,6 @@ export interface GetUserResponse {
         summary: ClendAccountTxSummary[];
     }[];
 }
-export interface GetVaultOHLCRequest {
-    vault: web3.PublicKey;
-}
-export interface VaultOHLCDataPoint {
-    time: number;
-    open: number;
-    high: number;
-    low: number;
-    close: number;
-}
-export interface GetVaultOHLCResponse {
-    data: VaultOHLCDataPoint[];
-}
 export interface UserWallet {
     balances: UserBalance[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@carrot-protocol/boost-http-client",
-  "version": "0.3.1-feat-get-ohlc-endpoint-dev-43df047",
+  "version": "0.3.1",
   "description": "HTTP client for Carrot Boost",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -27,8 +27,12 @@ import {
   BankEmissionsMode,
   WithdrawEmissionsRequest,
   WithdrawEmissionsResponse,
-  GetVaultOHLCResponse,
-  GetVaultOHLCRequest,
+  DepositRequest,
+  DepositResponse,
+  WithdrawRequest,
+  WithdrawResponse,
+  GetAccountResponse,
+  GetAccountRequest,
 } from "./types";
 import encode from "bs58";
 
@@ -46,12 +50,13 @@ export class Client {
   private readonly baseUrl: string;
   private readonly http: AxiosInstance;
   private readonly provider: AnchorProvider;
+  private readonly dryRun: boolean;
 
   /**
    * Create a new Carrot Boost API client
    * @param baseUrl Base URL for the API
    */
-  constructor(baseUrl: string, provider?: AnchorProvider) {
+  constructor(baseUrl: string, provider?: AnchorProvider, dryRun?: boolean) {
     this.baseUrl = new URL(baseUrl).toString();
     this.http = axios.create({
       baseURL: this.baseUrl,
@@ -62,6 +67,7 @@ export class Client {
     if (!provider) {
       provider = getDummyProvider();
     }
+    this.dryRun = dryRun ?? false;
     this.provider = provider;
   }
 
@@ -74,6 +80,11 @@ export class Client {
     unsignedBase64Tx: string,
     userRequestId: string,
   ): Promise<string> {
+    if (this.dryRun) {
+      // for debugging purposes only
+      console.log("unsigedBase64Tx", unsignedBase64Tx);
+    }
+
     // deserialize into tx obj
     const txBytes = Buffer.from(unsignedBase64Tx, "base64");
     const tx = web3.VersionedTransaction.deserialize(new Uint8Array(txBytes));
@@ -94,7 +105,11 @@ export class Client {
     };
 
     // send to api
-    await handleApiCall(() => this.http.post(`send`, sendRequest));
+    if (!this.dryRun) {
+      await handleApiCall(() => this.http.post(`send`, sendRequest));
+    } else {
+      console.warn("dry run enabled, did not send tx");
+    }
 
     // return txsig
     return encode.encode(txSig);
@@ -108,6 +123,155 @@ export class Client {
     return handleApiCall(() => this.http.get(""));
   }
 
+  /**
+   * Fetch and parse a single clend account by pubkey
+   */
+  async getAccount(
+    account: GetAccountRequest["account"],
+    getClendAccountSummary: GetAccountRequest["getClendAccountSummary"],
+  ): Promise<GetAccountResponse> {
+    const body = await handleApiCall(() =>
+      this.http.get(
+        `/account?account=${account.toString()}&getClendAccountSummary=${getClendAccountSummary}`,
+      ),
+    );
+    const jsonRawResponse: any = JSON.parse(body);
+    return this.parseClendAccountWithSummary(
+      jsonRawResponse,
+      getClendAccountSummary,
+    );
+  }
+
+  /**
+   * Helper to parse a clend account summary array from API response
+   */
+  private parseClendAccountSummary(summaryArr: any[]): ClendAccountTxSummary[] {
+    return summaryArr.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;
+        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;
+    });
+  }
+
+  private parseClendAccountWithSummary(
+    accountData: any,
+    getClendAccountSummary: boolean,
+  ): GetAccountResponse {
+    // 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),
+    };
+
+    // B. Parse the associated Summary array for the account
+    let summary: ClendAccountTxSummary[] = [];
+    if (getClendAccountSummary && accountData.summary) {
+      summary = this.parseClendAccountSummary(accountData.summary);
+    }
+
+    // C. Combine the parsed account and its summary
+    return { clendAccount, summary };
+  }
+
   async getUser(
     user: web3.PublicKey,
     groups: web3.PublicKey[],
@@ -141,137 +305,8 @@ export class Client {
     // 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),
-        };
-
-        // 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;
-          });
-        }
-
-        // C. Combine the parsed account and its summary
-        return { clendAccount, summary };
-      },
+      (accountData: any) =>
+        this.parseClendAccountWithSummary(accountData, getClendAccountSummary),
     );
 
     // 3. Return the final, correctly structured response object.
@@ -358,23 +393,59 @@ export class Client {
     return response;
   }
 
-  /**
-   * Get vault OHLC graph data
-   * @param vaultAddress vault public key
-   * @returns OHLC graph data
-   */
-  async getVaultOHLC(
-    vaultAddress: GetVaultOHLCRequest["vault"],
-  ): Promise<GetVaultOHLCResponse> {
+  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.get(`/vaultOhlc?vault=${vaultAddress.toString()}`),
+      this.http.post("deposit", JSON.stringify(req)),
     );
 
-    const response: GetVaultOHLCResponse = {
-      data: JSON.parse(body),
+    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,
     };
 
-    return response;
+    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;
   }
 
   /**

package/src/types.ts

@@ -6,6 +6,37 @@ export interface SendRequest {
   txns: string[];
 }
 
+/**
+ * Request to deposit collateral
+ */
+export interface DepositRequest {
+  owner: web3.PublicKey;
+  clendGroup: web3.PublicKey;
+  clendAccount: web3.PublicKey | null;
+  inputTokenMint: web3.PublicKey;
+  depositAmountUi: number;
+}
+
+export interface DepositResponse {
+  userRequestId: string;
+  unsignedBase64Tx: string;
+}
+
+/**
+ * Request to withdraw collateral
+ */
+export interface WithdrawRequest {
+  clendAccount: web3.PublicKey;
+  outputTokenMint: web3.PublicKey;
+  withdrawAmountUi: number;
+  withdrawAll: boolean;
+}
+
+export interface WithdrawResponse {
+  userRequestId: string;
+  unsignedBase64Tx: string;
+}
+
 /**
  * Request to deposit collateral and create a leveraged position
  */
@@ -98,6 +129,16 @@ export interface GroupAndBanks {
   banks: Bank[];
 }
 
+export interface GetAccountRequest {
+  account: web3.PublicKey;
+  getClendAccountSummary: boolean;
+}
+
+export interface GetAccountResponse {
+  clendAccount: ClendAccount;
+  summary: ClendAccountTxSummary[];
+}
+
 export interface GetUserRequest {
   groups: web3.PublicKey[];
   user: web3.PublicKey;
@@ -112,22 +153,6 @@ export interface GetUserResponse {
   }[];
 }
 
-export interface GetVaultOHLCRequest {
-  vault: web3.PublicKey;
-}
-
-export interface VaultOHLCDataPoint {
-  time: number;
-  open: number;
-  high: number;
-  low: number;
-  close: number;
-}
-
-export interface GetVaultOHLCResponse {
-  data: VaultOHLCDataPoint[];
-}
-
 export interface UserWallet {
   balances: UserBalance[];
 }