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

package/dist/index.d.ts

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

package/dist/index.js

@@ -99,159 +99,127 @@ class Client {
     async index() {
         return handleApiCall(() => this.http.get(""));
     }
-    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.
+    /**
+     * 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}`));
         const jsonRawResponse = JSON.parse(body);
-        // 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),
-        }));
+        // get tokens still in user wallet
         const wallet = {
-            balances: walletBalances,
+            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),
         };
-        // 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,
-                };
+        // 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),
             });
-            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),
+        }
+        // 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: [],
             };
-            // 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;
-                });
+            // 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;
             }
-            // C. Combine the parsed account and its summary
-            return { clendAccount, summary };
-        });
-        // 3. Return the final, correctly structured response object.
-        return {
-            wallet,
-            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);
+            // 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);
             }
-            groups.push({ group, groupName, banks });
+            summary.push(txSummary);
         }
-        const response = {
-            groups,
+        return {
+            wallet,
+            clendAccount,
+            summary,
         };
-        return response;
     }
     /**
      * Get market details
@@ -261,17 +229,13 @@ class Client {
     async getGroup(groupAddress) {
         const body = await handleApiCall(() => this.http.get(`/group?group=${groupAddress.toString()}`));
         const marketJson = JSON.parse(body);
-        const group = {
-            group: new anchor_1.web3.PublicKey(marketJson.group.group),
-            groupName: marketJson.group.groupName,
-            banks: [],
-        };
-        for (const bankJson of marketJson.group.banks) {
+        const banks = [];
+        for (const bankJson of marketJson.banks) {
             const bank = parseBank(bankJson);
-            group.banks.push(bank);
+            banks.push(bank);
         }
         const response = {
-            group,
+            banks,
         };
         return response;
     }
@@ -294,18 +258,15 @@ class Client {
      * @param request Deposit leverage request parameters
      * @returns Deposit leverage operation result
      */
-    async depositLeverage(clendGroup, clendAccount, inputTokenMint, assetTokenMint, liabilityTokenMint, uiAmount, leverage, slippageBps) {
-        if (!inputTokenMint.equals(assetTokenMint) &&
-            !inputTokenMint.equals(liabilityTokenMint)) {
+    async depositLeverage(inputMint, assetMint, liabilityMint, uiAmount, leverage, slippageBps) {
+        if (!inputMint.equals(assetMint) || !inputMint.equals(liabilityMint)) {
             throw new Error("Input mint must be the same as the asset or liability mint");
         }
         const req = {
             owner: this.address(),
-            clendGroup,
-            clendAccount,
-            inputTokenMint,
-            assetTokenMint,
-            liabilityTokenMint,
+            inputMint,
+            assetMint,
+            liabilityMint,
             depositAmountUi: uiAmount,
             leverage,
             slippageBps,
@@ -320,11 +281,9 @@ class Client {
      * @param request Adjust leverage request parameters
      * @returns Adjust leverage operation result
      */
-    async adjustLeverage(clendAccount, assetTokenMint, liabilityTokenMint, leverage, slippageBps) {
+    async adjustLeverage(leverage, slippageBps) {
         const req = {
-            clendAccount,
-            assetTokenMint,
-            liabilityTokenMint,
+            owner: this.address(),
             leverage,
             slippageBps,
         };
@@ -338,12 +297,10 @@ class Client {
      * @param request Withdraw leverage request parameters
      * @returns Withdraw leverage operation result
      */
-    async withdrawLeverage(clendAccount, outputTokenMint, assetTokenMint, liabilityTokenMint, uiAmount, slippageBps, withdrawAll) {
+    async withdrawLeverage(selectedTokenMint, uiAmount, slippageBps, withdrawAll) {
         const req = {
-            clendAccount,
-            outputTokenMint,
-            assetTokenMint,
-            liabilityTokenMint,
+            owner: this.address(),
+            selectedTokenMint,
             withdrawAmountUi: uiAmount,
             slippageBps,
             withdrawAll,
@@ -353,21 +310,16 @@ class Client {
         const txSig = await this.send(withdrawLeverageResponse.unsignedBase64Tx, withdrawLeverageResponse.userRequestId);
         return txSig;
     }
-    /**
-     * 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;
+function handleStatusCode(statusCode) {
+    switch (statusCode) {
+        case 200:
+            break;
+        default:
+            throw new Error(`unexpected status code: ${statusCode}`);
+    }
+}
 // Helper function to handle API calls
 async function handleApiCall(call) {
     try {
@@ -392,17 +344,6 @@ 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),
@@ -416,7 +357,6 @@ 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),
@@ -428,6 +368,5 @@ function parseBank(bankJson) {
         depositLimitUi: Number(bankJson.depositLimitUi),
         borrowLimit: new anchor_1.BN(bankJson.borrowLimit, "hex"),
         borrowLimitUi: Number(bankJson.borrowLimitUi),
-        emissions: bankEmissions,
     };
 }

package/dist/types.d.ts

@@ -8,11 +8,9 @@ export interface SendRequest {
  */
 export interface DepositLeverageRequest {
     owner: web3.PublicKey;
-    clendGroup: web3.PublicKey;
-    clendAccount: web3.PublicKey | null;
-    inputTokenMint: web3.PublicKey;
-    assetTokenMint: web3.PublicKey;
-    liabilityTokenMint: web3.PublicKey;
+    inputMint: web3.PublicKey;
+    assetMint: web3.PublicKey;
+    liabilityMint: web3.PublicKey;
     depositAmountUi: number;
     leverage: number;
     slippageBps: number;
@@ -28,9 +26,7 @@ export interface DepositLeverageResponse {
  * Request to adjust the leverage of an existing position
  */
 export interface AdjustLeverageRequest {
-    clendAccount: web3.PublicKey;
-    assetTokenMint: web3.PublicKey;
-    liabilityTokenMint: web3.PublicKey;
+    owner: web3.PublicKey;
     leverage: number;
     slippageBps: number;
 }
@@ -45,10 +41,8 @@ export interface AdjustLeverageResponse {
  * Request to withdraw from a leveraged position
  */
 export interface WithdrawLeverageRequest {
-    clendAccount: web3.PublicKey;
-    outputTokenMint: web3.PublicKey;
-    assetTokenMint: web3.PublicKey;
-    liabilityTokenMint: web3.PublicKey;
+    owner: web3.PublicKey;
+    selectedTokenMint: web3.PublicKey;
     withdrawAmountUi: number;
     slippageBps: number;
     withdrawAll: boolean;
@@ -60,88 +54,52 @@ export interface WithdrawLeverageResponse {
     userRequestId: string;
     unsignedBase64Tx: string;
 }
-/**
- * Request to withdraw emissions from a bank
- */
-export interface WithdrawEmissionsRequest {
-    owner: web3.PublicKey;
-}
-/**
- * Response for withdraw emissions operation
- */
-export interface WithdrawEmissionsResponse {
-    userRequestId: string;
-    unsignedBase64Tx: string;
-}
-export interface GetGroupsResponse {
-    groups: GroupAndBanks[];
-}
 export interface GetGroupResponse {
-    group: GroupAndBanks;
-}
-export interface GroupAndBanks {
-    group: web3.PublicKey;
-    groupName: string;
     banks: Bank[];
 }
 export interface GetUserRequest {
-    groups: web3.PublicKey[];
-    user: web3.PublicKey;
-    getClendAccountSummary: boolean;
+    user?: web3.PublicKey;
+    getClendAccountSummary?: boolean;
 }
 export interface GetUserResponse {
     wallet: UserWallet;
-    clendAccounts: {
-        clendAccount: ClendAccount;
-        summary: ClendAccountTxSummary[];
-    }[];
+    clendAccount: ClendAccount | undefined;
+    summary: ClendAccountTxSummary[];
 }
 export interface UserWallet {
-    balances: UserBalance[];
-}
-export interface UserBalance {
-    mint: web3.PublicKey;
-    balance: BN;
-    balanceUi: number;
+    usdcBalance: BN;
+    usdcBalanceUi: number;
+    jlpBalance: BN;
+    jlpBalanceUi: number;
+    solBalance: BN;
+    solBalanceUi: number;
 }
 export interface ClendAccount {
-    key: web3.PublicKey;
-    group: web3.PublicKey;
-    balances: ClendAccountBalance[];
+    balances: Balance[];
     netValue: number;
     netApy: number;
     pnl: number;
-    totalEmissionsApy: number;
     totalAssetValue: number;
     totalLiabilityValue: number;
     healthFactorNotional: number;
     healthFactorRiskAdjusted: number;
     notionalLeverage: number;
     riskAdjustedLeverage: number;
+    liquidationPrice: number;
+    liquidationPriceChangePercentage: number;
     notionalLtv: number;
     riskAdjustedLtv: number;
 }
-export interface ClendAccountBalance {
+export interface Balance {
     mint: web3.PublicKey;
     bank: web3.PublicKey;
-    tokenYieldApy: number;
     assetBalance: BN;
     assetBalanceUi: number;
     assetValue: number;
-    assetEmissionsApy: number;
     liabilityBalance: BN;
     liabilityBalanceUi: number;
     liabilityValue: number;
-    liabilityBorrowCostApy: number;
-    liabilityEmissionsApy: number;
-    emissionsOutstandingAndUnclaimed: BN;
-    emissionsOutstandingAndUnclaimedUi: number;
     price: number;
-    liquidation: ClendAccountAssetLiquidation | null;
-}
-export interface ClendAccountAssetLiquidation {
-    price: number;
-    changePercentage: number;
 }
 export interface GetBankResponse {
     bank: Bank;
@@ -150,7 +108,6 @@ export interface Bank {
     group: web3.PublicKey;
     key: web3.PublicKey;
     mint: web3.PublicKey;
-    tokenYieldApy: number;
     supplyApy: number;
     borrowApy: number;
     utilizationRate: number;
@@ -171,17 +128,7 @@ export interface Bank {
     depositLimitUi: number;
     borrowLimit: BN;
     borrowLimitUi: number;
-    emissions: BankEmissions | null;
-}
-export interface BankEmissions {
-    emissionsMode: BankEmissionsMode;
-    emissionsApy: number;
-    emissionsMint: web3.PublicKey;
-    emissionsTokenPrice: number;
-    emissionsRate: BN;
-    emissionsRemainingUi: number;
 }
-export type BankEmissionsMode = "LENDING_ONLY" | "BORROW_ONLY" | "LENDING_AND_BORROWING";
 export interface ClendAccountTxSummary {
     txSig: string;
     time: Date;

package/dist/utils.d.ts

@@ -1,3 +1,5 @@
 import { web3 } from "@coral-xyz/anchor";
 import { ClendAccount } from "./types";
 export declare function netValueInToken(clendAccount: ClendAccount, tokenMint: web3.PublicKey): number;
+export declare function getProductionGroups(): web3.PublicKey[];
+export declare function getStagingGroups(): web3.PublicKey[];

package/dist/utils.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.netValueInToken = netValueInToken;
+exports.getProductionGroups = getProductionGroups;
+exports.getStagingGroups = getStagingGroups;
+const anchor_1 = require("@coral-xyz/anchor");
 // returns the net value of the clend account in a given tokens price
 function netValueInToken(clendAccount, tokenMint) {
     const clendAccountTokenBalance = clendAccount.balances.find((balance) => balance.mint.equals(tokenMint));
@@ -9,3 +12,9 @@ function netValueInToken(clendAccount, tokenMint) {
     }
     return clendAccount.netValue / clendAccountTokenBalance.price;
 }
+function getProductionGroups() {
+    return [new anchor_1.web3.PublicKey("9bCWxAXFdWQ9GcZTSU3G636T6EyGXYMgaWR74yc7QZz8")];
+}
+function getStagingGroups() {
+    return [new anchor_1.web3.PublicKey("HKMDWLBK7yUmorSx9argg2rYcro6KoWf41N57FccKRP5")];
+}