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

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AnchorProvider, web3 } from "@coral-xyz/anchor";
-import { GetBankResponse, GetUserResponse, GetGroupResponse, GetUserRequest } from "./types";
+import { GetBankResponse, GetUserResponse, GetGroupResponse, GetGroupsResponse } from "./types";
 export * from "./types";
 export * from "./utils";
 export * as Common from "@carrot-protocol/clend-common";
@@ -22,12 +22,13 @@ export declare class Client {
      * @returns Index details
      */
     index(): Promise<any>;
+    getUser(user: web3.PublicKey, groups: web3.PublicKey[], getClendAccountSummary: boolean): Promise<GetUserResponse>;
     /**
-     * Get user details for a wallet
-     * @param user wallet public key
-     * @returns User details
+     * Get all groups
+     * @param includeBankData Whether to include bank data in the response, if not strictly necessary keep false
+     * @returns All groups
      */
-    getUser(request: GetUserRequest): Promise<GetUserResponse>;
+    getGroups(includeBankData: boolean): Promise<GetGroupsResponse>;
     /**
      * Get market details
      * @param groupAddress group public key
@@ -40,22 +41,29 @@ export declare class Client {
      * @returns Bank details
      */
     getBank(bankAddress: web3.PublicKey): Promise<GetBankResponse>;
+    deposit(clendGroup: web3.PublicKey, clendAccount: web3.PublicKey | null, inputTokenMint: web3.PublicKey, uiAmount: number): Promise<string>;
+    withdraw(clendAccount: web3.PublicKey, outputTokenMint: web3.PublicKey, uiAmount: number): Promise<string>;
     /**
      * Deposit collateral and create a leveraged position
      * @param request Deposit leverage request parameters
      * @returns Deposit leverage operation result
      */
-    depositLeverage(inputMint: web3.PublicKey, assetMint: web3.PublicKey, liabilityMint: web3.PublicKey, uiAmount: number, leverage: number, slippageBps: number): Promise<string>;
+    depositLeverage(clendGroup: web3.PublicKey, clendAccount: web3.PublicKey | null, inputTokenMint: web3.PublicKey, assetTokenMint: web3.PublicKey, liabilityTokenMint: web3.PublicKey, uiAmount: number, leverage: number, slippageBps: number): Promise<string>;
     /**
      * Adjust the leverage of an existing position
      * @param request Adjust leverage request parameters
      * @returns Adjust leverage operation result
      */
-    adjustLeverage(leverage: number, slippageBps: number): Promise<any>;
+    adjustLeverage(clendAccount: web3.PublicKey, assetTokenMint: web3.PublicKey, liabilityTokenMint: web3.PublicKey, leverage: number, slippageBps: number): Promise<string>;
     /**
      * Withdraw from or close a leveraged position
      * @param request Withdraw leverage request parameters
      * @returns Withdraw leverage operation result
      */
-    withdrawLeverage(selectedTokenMint: web3.PublicKey, uiAmount: number, slippageBps: number, withdrawAll: boolean): Promise<any>;
+    withdrawLeverage(clendAccount: web3.PublicKey, outputTokenMint: web3.PublicKey, assetTokenMint: web3.PublicKey, liabilityTokenMint: web3.PublicKey, uiAmount: number, slippageBps: number, withdrawAll: boolean): Promise<string>;
+    /**
+     * Withdraw emissions from a bank
+     * @returns Withdraw emissions operation result
+     */
+    withdrawEmissions(): Promise<string>;
 }

package/dist/index.js

@@ -99,128 +99,160 @@ class Client {
     async index() {
         return handleApiCall(() => this.http.get(""));
     }
-    /**
-     * Get user details for a wallet
-     * @param user wallet public key
-     * @returns User details
-     */
-    async getUser(request) {
-        // use loaded wallet if not provided
-        let user = request.user;
-        if (!user) {
-            user = this.address();
-        }
-        const body = await handleApiCall(() => this.http.get(`/user?user=${user.toString()}&getClendAccountSummary=${request.getClendAccountSummary}`));
+    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}`));
+        // Parse the raw string body into a JSON object.
         const jsonRawResponse = JSON.parse(body);
-        // get tokens still in user wallet
+        // 1. Parse Wallet Balances
+        // This section correctly iterates through the wallet balances and creates typed objects.
+        const walletBalances = (jsonRawResponse.wallet.balances || []).map((b) => ({
+            mint: new anchor_1.web3.PublicKey(b.mint),
+            balance: new anchor_1.BN(b.balance, "hex"),
+            balanceUi: Number(b.balanceUi),
+        }));
         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),
+            balances: walletBalances,
         };
-        // if no clend account, return undefined for clend
-        if (!jsonRawResponse.clendAccount) {
-            return {
-                wallet,
-                clendAccount: undefined,
-                summary: [],
-            };
-        }
-        // 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),
+        // 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,
+                };
             });
-        }
-        // 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),
-            liquidationPrice: Number(jsonRawResponse.clendAccount.liquidationPrice),
-            liquidationPriceChangePercentage: Number(jsonRawResponse.clendAccount.liquidationPriceChangePercentage),
-            notionalLtv: Number(jsonRawResponse.clendAccount.notionalLtv),
-            riskAdjustedLtv: Number(jsonRawResponse.clendAccount.riskAdjustedLtv),
-        };
-        // get tx summary for each account
-        const summary = [];
-        for (const s of jsonRawResponse.summary) {
-            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: undefined,
-                events: [],
+            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),
             };
-            // parse inputs if they exist
-            if (s.input) {
-                const 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
-                        ? Boolean(s.input.openPosition)
-                        : null,
-                    closePosition: s.input.closePosition
-                        ? Boolean(s.input.closePosition)
-                        : null,
-                };
-                txSummary.input = input;
-            }
-            // get events for each summary
-            for (const event of s.events) {
-                let closeBalance = null;
-                if (event.closeBalance !== null) {
-                    closeBalance = Boolean(event.closeBalance);
-                }
-                // parse amount
-                const clendAccountEvent = {
-                    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,
-                };
-                txSummary.events.push(clendAccountEvent);
+            // 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;
+                });
             }
-            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) {
+        const body = await handleApiCall(() => this.http.get(`/groups?includeBankData=${includeBankData}`));
+        const marketJson = JSON.parse(body);
+        const groups = [];
+        for (const groupJson of marketJson.groups) {
+            const group = new anchor_1.web3.PublicKey(groupJson.group);
+            const groupName = groupJson.groupName;
+            const banks = [];
+            for (const bankJson of groupJson.banks) {
+                const bank = parseBank(bankJson);
+                banks.push(bank);
+            }
+            groups.push({ group, groupName, banks });
+        }
+        const response = {
+            groups,
+        };
+        return response;
+    }
     /**
      * Get market details
      * @param groupAddress group public key
@@ -229,13 +261,17 @@ class Client {
     async getGroup(groupAddress) {
         const body = await handleApiCall(() => this.http.get(`/group?group=${groupAddress.toString()}`));
         const marketJson = JSON.parse(body);
-        const banks = [];
-        for (const bankJson of marketJson.banks) {
+        const group = {
+            group: new anchor_1.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 = {
-            banks,
+            group,
         };
         return response;
     }
@@ -253,20 +289,47 @@ class Client {
         };
         return response;
     }
+    async deposit(clendGroup, clendAccount, inputTokenMint, uiAmount) {
+        const req = {
+            owner: this.address(),
+            clendGroup,
+            clendAccount,
+            inputTokenMint,
+            depositAmountUi: uiAmount,
+        };
+        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) {
+        const req = {
+            clendAccount,
+            outputTokenMint,
+            withdrawAmountUi: uiAmount,
+        };
+        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
      * @param request Deposit leverage request parameters
      * @returns Deposit leverage operation result
      */
-    async depositLeverage(inputMint, assetMint, liabilityMint, uiAmount, leverage, slippageBps) {
-        if (!inputMint.equals(assetMint) || !inputMint.equals(liabilityMint)) {
+    async depositLeverage(clendGroup, clendAccount, inputTokenMint, assetTokenMint, liabilityTokenMint, uiAmount, leverage, slippageBps) {
+        if (!inputTokenMint.equals(assetTokenMint) &&
+            !inputTokenMint.equals(liabilityTokenMint)) {
             throw new Error("Input mint must be the same as the asset or liability mint");
         }
         const req = {
             owner: this.address(),
-            inputMint,
-            assetMint,
-            liabilityMint,
+            clendGroup,
+            clendAccount,
+            inputTokenMint,
+            assetTokenMint,
+            liabilityTokenMint,
             depositAmountUi: uiAmount,
             leverage,
             slippageBps,
@@ -281,9 +344,11 @@ class Client {
      * @param request Adjust leverage request parameters
      * @returns Adjust leverage operation result
      */
-    async adjustLeverage(leverage, slippageBps) {
+    async adjustLeverage(clendAccount, assetTokenMint, liabilityTokenMint, leverage, slippageBps) {
         const req = {
-            owner: this.address(),
+            clendAccount,
+            assetTokenMint,
+            liabilityTokenMint,
             leverage,
             slippageBps,
         };
@@ -297,10 +362,12 @@ class Client {
      * @param request Withdraw leverage request parameters
      * @returns Withdraw leverage operation result
      */
-    async withdrawLeverage(selectedTokenMint, uiAmount, slippageBps, withdrawAll) {
+    async withdrawLeverage(clendAccount, outputTokenMint, assetTokenMint, liabilityTokenMint, uiAmount, slippageBps, withdrawAll) {
         const req = {
-            owner: this.address(),
-            selectedTokenMint,
+            clendAccount,
+            outputTokenMint,
+            assetTokenMint,
+            liabilityTokenMint,
             withdrawAmountUi: uiAmount,
             slippageBps,
             withdrawAll,
@@ -310,16 +377,21 @@ class Client {
         const txSig = await this.send(withdrawLeverageResponse.unsignedBase64Tx, withdrawLeverageResponse.userRequestId);
         return txSig;
     }
-}
-exports.Client = Client;
-function handleStatusCode(statusCode) {
-    switch (statusCode) {
-        case 200:
-            break;
-        default:
-            throw new Error(`unexpected status code: ${statusCode}`);
+    /**
+     * Withdraw emissions from a bank
+     * @returns Withdraw emissions operation result
+     */
+    async withdrawEmissions() {
+        const req = {
+            owner: this.address(),
+        };
+        const body = await handleApiCall(() => this.http.post("emissions/withdraw", JSON.stringify(req)));
+        const withdrawEmissionsResponse = JSON.parse(body);
+        const txSig = await this.send(withdrawEmissionsResponse.unsignedBase64Tx, withdrawEmissionsResponse.userRequestId);
+        return txSig;
     }
 }
+exports.Client = Client;
 // Helper function to handle API calls
 async function handleApiCall(call) {
     try {
@@ -344,6 +416,17 @@ function getDummyProvider() {
     });
 }
 function parseBank(bankJson) {
+    let bankEmissions = null;
+    if (bankJson.emissions) {
+        bankEmissions = {
+            emissionsMode: bankJson.emissions.emissionsMode,
+            emissionsApy: Number(bankJson.emissions.emissionsApy),
+            emissionsMint: new anchor_1.web3.PublicKey(bankJson.emissions.emissionsMint),
+            emissionsTokenPrice: Number(bankJson.emissions.emissionsTokenPrice),
+            emissionsRate: new anchor_1.BN(bankJson.emissions.emissionsRate, "hex"),
+            emissionsRemainingUi: Number(bankJson.emissions.emissionsRemainingUi),
+        };
+    }
     return {
         mint: new anchor_1.web3.PublicKey(bankJson.mint),
         key: new anchor_1.web3.PublicKey(bankJson.key),
@@ -357,6 +440,7 @@ function parseBank(bankJson) {
         assetMaintWeight: Number(bankJson.assetMaintWeight),
         totalAssetShares: Number(bankJson.totalAssetShares),
         assetShareValue: Number(bankJson.assetShareValue),
+        tokenYieldApy: Number(bankJson.tokenYieldApy),
         liabilityAmount: new anchor_1.BN(bankJson.liabilityAmount, "hex"),
         liabilityAmountUi: Number(bankJson.liabilityAmountUi),
         liabilityInitWeight: Number(bankJson.liabilityInitWeight),
@@ -368,5 +452,6 @@ function parseBank(bankJson) {
         depositLimitUi: Number(bankJson.depositLimitUi),
         borrowLimit: new anchor_1.BN(bankJson.borrowLimit, "hex"),
         borrowLimitUi: Number(bankJson.borrowLimitUi),
+        emissions: bankEmissions,
     };
 }