@pendle/sdk-boros 1.8.0 → 1.8.1

package/dist/entities/exchange/exchange.js

@@ -19,8 +19,7 @@ class Exchange {
     walletClient;
     root;
     accountId;
-    borosCoreSdk;
-    borosSendTxsBotSdk;
+    openApiSdk;
     contractsFactory;
     publicClient;
     agent;
@@ -28,8 +27,7 @@ class Exchange {
         this.walletClient = walletClient;
         this.root = root;
         this.accountId = accountId;
-        this.borosCoreSdk = backend_1.BorosBackend.getCoreSdk();
-        this.borosSendTxsBotSdk = backend_1.BorosBackend.getSendTxsBotSdk();
+        this.openApiSdk = backend_1.BorosBackend.getOpenApiSdk();
         this.contractsFactory = new contracts_factory_1.ContractsFactory(rpcUrls);
         this.publicClient = this.contractsFactory.getRpcClient();
         this.agent = agent;
@@ -44,23 +42,19 @@ class Exchange {
         return this.agent;
     }
     async enterMarkets(cross, marketIds, nonces) {
-        const marketIdsString = marketIds.map((marketId) => marketId.toString()).join(',');
-        const { data: enterMarketsCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetEnterExitMarketsCalldata({
+        const { data: enterMarketsCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildEnterMarkets({
             isCross: cross,
-            marketIds: marketIdsString,
-            isEnter: true,
+            marketIds,
         });
-        const enterMarketsResponses = await this.bulkSignAndExecute(enterMarketsCalldataResponse.calldatas, nonces);
+        const enterMarketsResponses = await this.bulkSignAndExecute(enterMarketsCalldataResponse.calls.map((call) => call.calldata), nonces);
         return enterMarketsResponses;
     }
     async exitMarkets(cross, marketIds, nonces) {
-        const marketIdsString = marketIds.map((marketId) => marketId.toString()).join(',');
-        const { data: exitMarketsCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetEnterExitMarketsCalldata({
+        const { data: exitMarketsCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildExitMarkets({
             isCross: cross,
-            marketIds: marketIdsString,
-            isEnter: false,
+            marketIds,
         });
-        const exitMarketsResponses = await this.bulkSignAndExecute(exitMarketsCalldataResponse.calldatas, nonces);
+        const exitMarketsResponses = await this.bulkSignAndExecute(exitMarketsCalldataResponse.calls.map((call) => call.calldata), nonces);
         return exitMarketsResponses;
     }
     async bulkSignAndExecute(calldatas, nonces, requireSuccess, skipReceipt) {
@@ -71,7 +65,7 @@ class Exchange {
             agent: this.getAgentForSigning(),
             nonces,
         });
-        const { data: executeResponses } = await this.borosSendTxsBotSdk.agent.agentControllerBulkAgentDirectCallV2({
+        const { data: executeResponses } = await this.openApiSdk.sendTxs.sendTxsControllerBulkCalls({
             datas: signs.map((sign) => ({
                 ...sign,
                 message: {
@@ -84,7 +78,9 @@ class Exchange {
         });
         const txHash = executeResponses.find((txResponse) => !txResponse.error)?.txHash;
         if (txHash) {
-            const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({ hash: txHash });
+            const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({
+                hash: txHash,
+            });
             const blockTimestamp = (await publicClient_1.publicClient.getBlock({ blockNumber: receipt.blockNumber })).timestamp;
             const logGroups = [];
             let events = [];
@@ -139,16 +135,22 @@ class Exchange {
     }
     async placeOrder(params) {
         const { marketAcc, marketId, side, size, limitTick, tif, slippage, nonces } = params;
-        const { data: placeOrderCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetPlaceOrderCalldataV4({
-            marketAcc,
-            marketId,
-            side,
-            size: size.toString(),
-            limitTick,
-            tif,
-            slippage,
+        const { data: placeOrderCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPlaceOrders({
+            orderRequests: [
+                {
+                    singleOrder: {
+                        marketAcc,
+                        marketId,
+                        side,
+                        size: size.toString(),
+                        limitTick,
+                        tif,
+                        slippage,
+                    },
+                },
+            ],
         });
-        const placeOrderResponses = await this.bulkSignAndExecute(placeOrderCalldataResponse.calldatas, nonces);
+        const placeOrderResponses = await this.bulkSignAndExecute(placeOrderCalldataResponse.calls.map((call) => call.calldata), nonces);
         const placeOrderResponse = placeOrderResponses[placeOrderResponses.length - 1];
         if ('error' in placeOrderResponse) {
             throw new Error(placeOrderResponse.error);
@@ -183,7 +185,7 @@ class Exchange {
         return results;
     }
     async bulkPlaceOrdersV5(request, options) {
-        const { data: bulkPlaceOrderCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetBulkPlaceOrderCalldataV7({
+        const { data: bulkPlaceOrderCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPlaceOrders({
             orderRequests: request.orderRequests.map((orderRequest) => {
                 if ('size' in orderRequest) {
                     return {
@@ -194,7 +196,7 @@ class Exchange {
                     };
                 }
                 return {
-                    bulkOrder: {
+                    bulkOrders: {
                         cross: orderRequest.cross,
                         bulks: orderRequest.bulks.map((bulk) => ({
                             marketId: bulk.marketId,
@@ -206,13 +208,13 @@ class Exchange {
                                 ...bulk.cancelData,
                                 ids: bulk.cancelData.ids.map((id) => id.toString()),
                             },
+                            slippage: orderRequest.slippage,
                         })),
-                        slippage: orderRequest.slippage,
                     },
                 };
             }),
         });
-        const responses = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calldatas, request.nonces, false, options?.skipReceipt);
+        const responses = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calls.map((call) => call.calldata), request.nonces, false, options?.skipReceipt);
         const parseSingleOrderResult = (index) => {
             const singleOrderRequest = request.orderRequests[index];
             const orderResponse = responses[index];
@@ -299,34 +301,34 @@ class Exchange {
         return results;
     }
     async bulkPlaceOrdersV4(request) {
-        const { data: bulkPlaceOrderCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetBulkPlaceOrderCalldataV6({
-            singleOrders: request.singleOrders
-                ? request.singleOrders.map((singleOrder) => ({
-                    ...singleOrder,
-                    size: singleOrder.size.toString(),
-                }))
-                : undefined,
-            bulkOrders: request.bulkOrders
-                ? request.bulkOrders
-                    .filter((bulkOrder) => bulkOrder.bulks.length > 0)
-                    .map((bulkOrder) => ({
-                    cross: bulkOrder.cross,
-                    bulks: bulkOrder.bulks.map((bulk) => ({
-                        marketId: bulk.marketId,
-                        orders: {
-                            ...bulk.orders,
-                            sizes: bulk.orders.sizes.map((size) => size.toString()),
-                        },
-                        cancelData: {
-                            ...bulk.cancelData,
-                            ids: bulk.cancelData.ids.map((id) => id.toString()),
-                        },
-                    })),
+        const singleOrderRequests = (request.singleOrders ?? []).map((singleOrder) => ({
+            singleOrder: {
+                ...singleOrder,
+                size: singleOrder.size.toString(),
+            },
+        }));
+        const bulkOrderRequestsFiltered = (request.bulkOrders ?? []).filter((bulkOrder) => bulkOrder.bulks.length > 0);
+        const bulkOrderRequests = bulkOrderRequestsFiltered.map((bulkOrder) => ({
+            bulkOrders: {
+                cross: bulkOrder.cross,
+                bulks: bulkOrder.bulks.map((bulk) => ({
+                    marketId: bulk.marketId,
+                    orders: {
+                        ...bulk.orders,
+                        sizes: bulk.orders.sizes.map((size) => size.toString()),
+                    },
+                    cancelData: {
+                        ...bulk.cancelData,
+                        ids: bulk.cancelData.ids.map((id) => id.toString()),
+                    },
                     slippage: bulkOrder.slippage,
-                }))
-                : undefined,
+                })),
+            },
+        }));
+        const { data: bulkPlaceOrderCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPlaceOrders({
+            orderRequests: [...singleOrderRequests, ...bulkOrderRequests],
         });
-        const responses = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calldatas, request.nonces);
+        const responses = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calls.map((call) => call.calldata), request.nonces);
         const startBulkIndex = request.bulkOrders ? responses.length - request.bulkOrders.length : 0;
         const bulkOrdersResponses = request.bulkOrders ? responses.slice(startBulkIndex) : undefined;
         const singleOrdersResponses = request.singleOrders && request.bulkOrders
@@ -412,17 +414,21 @@ class Exchange {
         };
     }
     async bulkPlaceOrdersV2(request) {
-        const { data: bulkPlaceOrderCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetBulkPlaceOrderCalldataV3({
-            marketAcc: request.marketAcc,
-            marketId: request.marketId,
-            sides: request.sides,
-            sizes: request.sizes.map((size) => size.toString()),
-            limitTicks: request.limitTicks,
-            tif: request.tif,
-            ammId: request.ammId,
-            slippage: request.slippage,
-        });
-        const placeOrdersResponse = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calldatas, request.nonces);
+        const { data: bulkPlaceOrderCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPlaceOrders({
+            orderRequests: request.sides.map((side, index) => ({
+                singleOrder: {
+                    marketAcc: request.marketAcc,
+                    marketId: request.marketId,
+                    side,
+                    size: request.sizes[index].toString(),
+                    limitTick: request.limitTicks[index],
+                    tif: request.tif,
+                    ammId: request.ammId,
+                    slippage: request.slippage,
+                },
+            })),
+        });
+        const placeOrdersResponse = await this.bulkSignAndExecute(bulkPlaceOrderCalldataResponse.calls.map((call) => call.calldata), request.nonces);
         return placeOrdersResponse.map((orderResponse, index) => {
             if ('error' in orderResponse) {
                 return {
@@ -461,14 +467,17 @@ class Exchange {
     }
     async cancelOrders(params) {
         const { marketAcc, marketId, cancelAll, orderIds, nonces } = params;
-        const orderIdsStr = orderIds.join(',');
-        const { data: cancelOrderCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetCancelOrderCalldataV3({
-            marketAcc,
-            marketId,
-            cancelAll,
-            orderIds: orderIdsStr,
+        const { data: cancelOrderCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildCancelOrders({
+            markets: [
+                {
+                    marketAcc,
+                    marketId,
+                    cancelAll,
+                    orderIds,
+                },
+            ],
         });
-        const cancelOrderResponses = await this.bulkSignAndExecute(cancelOrderCalldataResponse.calldatas, nonces);
+        const cancelOrderResponses = await this.bulkSignAndExecute(cancelOrderCalldataResponse.calls.map((call) => call.calldata), nonces);
         const cancelOrderResponse = cancelOrderResponses[cancelOrderResponses.length - 1];
         if ('error' in cancelOrderResponse) {
             throw new Error(cancelOrderResponse.error);
@@ -493,15 +502,29 @@ class Exchange {
         return cancelOrderCalldataResponse;
     }
     async getGasBalance() {
-        const { data: getGasBalanceCalldataResponse } = await this.borosCoreSdk.accounts.accountsControllerGetAccountGasBalance({
-            userAddress: this.root,
+        const { data: getGasBalanceCalldataResponse } = await this.openApiSdk.accounts.accountsV2ControllerGetAccountGasBalance({
+            root: this.root,
         });
         return getGasBalanceCalldataResponse.balanceInUSD;
     }
     async payTreasury(params) {
-        const { nonces, ...restParams } = params;
-        const { data: payTreasuryCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetPayTreasuryCalldataV2(restParams);
-        const payTreasuryResponse = await this.bulkSignAndExecute(payTreasuryCalldataResponse.calldatas, nonces);
+        const { nonces, isCross, marketId, usdAmount } = params;
+        const [market, assets] = await Promise.all([this.getMarketInfo(marketId), this.getAssets()]);
+        const asset = assets.assets.find((a) => a.tokenId === market.tokenId);
+        if (!asset) {
+            throw new Error(`payTreasury: no asset found for market ${marketId} tokenId ${market.tokenId}`);
+        }
+        const usdPrice = Number(asset.usdPrice);
+        if (!Number.isFinite(usdPrice) || usdPrice <= 0) {
+            throw new Error(`payTreasury: invalid usdPrice "${asset.usdPrice}" for tokenId ${asset.tokenId}`);
+        }
+        const nativeAmount = BigInt(Math.floor((usdAmount / usdPrice) * 10 ** asset.decimals));
+        const { data: payTreasuryCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPayTreasury({
+            isCross,
+            marketId,
+            amount: nativeAmount.toString(),
+        });
+        const payTreasuryResponse = await this.bulkSignAndExecute(payTreasuryCalldataResponse.calls.map((call) => call.calldata), nonces);
         return payTreasuryResponse;
     }
     async scheduleCancel(time) {
@@ -514,25 +537,23 @@ class Exchange {
         }
         const expiredTime = expiry_s ?? Math.floor(Date.now() / 1000) + 7 * 24 * 60 * 60;
         const approveAgentData = await agentToUse.approveAgent(this.walletClient, expiredTime, nonce);
-        const { data: approveAgentResponse } = await this.borosSendTxsBotSdk.agent.agentControllerApproveAgent({
+        const { data: approveAgentResponse } = await this.openApiSdk.sendTxs.sendTxsControllerApprove({
             approveAgentCalldata: approveAgentData,
         });
         return approveAgentResponse;
     }
     async deposit(params) {
         const { userAddress, tokenId, amount, accountId, marketId } = params;
+        const marketAcc = utils_1.MarketAccLib.pack(userAddress, accountId, tokenId, marketId);
         const [depositCalldataResponse, tokenAddress] = await Promise.all([
-            this.borosCoreSdk.calldata.calldataControllerGetDepositCalldataV2({
-                userAddress,
-                tokenId,
+            this.openApiSdk.calldataBuilderUserSigned.calldataBuilderUserControllerBuildDeposit({
+                marketAcc,
                 amount: amount.toString(),
-                accountId,
-                marketId,
             }),
             params.tokenAddress
                 ? params.tokenAddress
-                : this.borosCoreSdk.assets.assetsControllerGetAllAssets().then((res) => {
-                    const tokenAddress = res.data.assets.find((asset) => asset.tokenId === tokenId)?.address;
+                : this.openApiSdk.assets.assetsControllerListAssets().then((res) => {
+                    const tokenAddress = res.data.results.find((asset) => asset.tokenId === tokenId)?.address;
                     return tokenAddress;
                 }),
         ]);
@@ -546,50 +567,59 @@ class Exchange {
             chain: this.walletClient.chain,
             type: 'eip1559',
         });
-        await publicClient_1.publicClient.waitForTransactionReceipt({ hash: approvalhash, confirmations: 1 });
+        await publicClient_1.publicClient.waitForTransactionReceipt({
+            hash: approvalhash,
+            confirmations: 1,
+        });
         const hash = await this.walletClient.sendTransaction({
             to: depositCalldataResponse.data.to,
-            data: depositCalldataResponse.data.data,
+            data: depositCalldataResponse.data.calldata,
             account: this.walletClient.account,
             chain: this.walletClient.chain,
             type: 'eip1559',
         });
-        const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({ hash, confirmations: 1 });
+        const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({
+            hash,
+            confirmations: 1,
+        });
         return receipt;
     }
     async withdraw(params) {
         const { userAddress, tokenId, amount } = params;
-        const { data: withdrawCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetWithdrawRequestCalldata({
-            userAddress,
+        const { data: withdrawCalldataResponse } = await this.openApiSdk.calldataBuilderUserSigned.calldataBuilderUserControllerBuildRequestWithdrawal({
+            root: userAddress,
             tokenId,
             amount: amount.toString(),
         });
         const hash = await this.walletClient.sendTransaction({
             to: withdrawCalldataResponse.to,
-            data: withdrawCalldataResponse.data,
+            data: withdrawCalldataResponse.calldata,
             account: this.walletClient.account,
             chain: this.walletClient.chain,
             type: 'eip1559',
         });
-        const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({ hash, confirmations: 1 });
+        const receipt = await publicClient_1.publicClient.waitForTransactionReceipt({
+            hash,
+            confirmations: 1,
+        });
         return receipt;
     }
     async cashTransfer(params) {
         const { marketId, isDeposit, amount, nonces } = params;
-        const { data: cashTransferCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetPositionTransferCalldataV3({
+        const { data: cashTransferCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildCashTransfer({
             marketId,
-            isDeposit,
+            direction: isDeposit ? 'CROSS_TO_ISOLATED' : 'ISOLATED_TO_CROSS',
             amount: amount.toString(),
         });
-        const response = await this.bulkSignAndExecute(cashTransferCalldataResponse.calldatas, nonces);
+        const response = await this.bulkSignAndExecute(cashTransferCalldataResponse.calls.map((call) => call.calldata), nonces);
         return response;
     }
     async cashTransferBatch(transfers, options) {
         if (transfers.length === 0)
             return [];
-        const calldataResponses = await Promise.allSettled(transfers.map((t) => this.borosCoreSdk.calldata.calldataControllerGetPositionTransferCalldataV3({
+        const calldataResponses = await Promise.allSettled(transfers.map((t) => this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildCashTransfer({
             marketId: t.marketId,
-            isDeposit: t.isDeposit,
+            direction: t.isDeposit ? 'CROSS_TO_ISOLATED' : 'ISOLATED_TO_CROSS',
             amount: t.amount.toString(),
         })));
         const slots = [];
@@ -598,7 +628,7 @@ class Exchange {
             const r = calldataResponses[i];
             const transfer = transfers[i];
             if (r.status === 'fulfilled') {
-                const cds = r.value.data.calldatas;
+                const cds = r.value.data.calls.map((call) => call.calldata);
                 slots.push({ kind: 'fetched', transfer, calldataCount: cds.length });
                 allCalldatas.push(...cds);
             }
@@ -625,29 +655,38 @@ class Exchange {
                 .map((r) => r.executeResponse?.txHash)
                 .find((h) => h !== undefined);
             if (!txHash) {
-                return { ...slot.transfer, error: 'cashTransferBatch returned no txHash' };
+                return {
+                    ...slot.transfer,
+                    error: 'cashTransferBatch returned no txHash',
+                };
             }
             return { ...slot.transfer, txHash };
         });
     }
     async closeActivePositions(params) {
         const { marketAcc, marketId, side, size, limitTick, tif, slippage, nonces } = params;
-        const { data: closeActivePositionsCalldataResponse } = await this.borosCoreSdk.calldata.calldataControllerGetCloseActiveMarketPositionV4({
-            marketAcc,
-            marketId,
-            side,
-            size: size.toString(),
-            limitTick,
-            tif,
-            slippage,
+        const { data: closeActivePositionsCalldataResponse } = await this.openApiSdk.calldataBuilderAgentExecutable.calldataBuilderAgentControllerBuildPlaceOrders({
+            orderRequests: [
+                {
+                    singleOrder: {
+                        marketAcc,
+                        marketId,
+                        side,
+                        size: size.toString(),
+                        limitTick,
+                        tif,
+                        slippage,
+                    },
+                },
+            ],
         });
-        const response = await this.bulkSignAndExecute(closeActivePositionsCalldataResponse.calldatas, nonces);
+        const response = await this.bulkSignAndExecute(closeActivePositionsCalldataResponse.calls.map((call) => call.calldata), nonces);
         return response;
     }
     async getAmmCutOffTimestamp(marketId) {
         const markets = await this.getMarkets();
         const market = markets.results.find((m) => m.marketId === marketId);
-        const ammContract = this.contractsFactory.getAmmContract(market.metadata?.ammAddress);
+        const ammContract = this.contractsFactory.getAmmContract(market.extConfig?.ammAddress);
         const ammState = await ammContract?.readState();
         return ammState ? Number(ammState.cutOffTimestamp) : undefined;
     }
@@ -673,7 +712,7 @@ class Exchange {
         const market = markets.results.find((m) => m.marketId === marketId);
         const marketContract = this.contractsFactory.getMarketContract(market.address);
         const explorerContract = this.contractsFactory.getExplorerContract((0, addresses_1.getExplorerContractAddress)());
-        const ammAddress = market.metadata?.ammAddress;
+        const ammAddress = market.extConfig?.ammAddress;
         const ammContract = ammAddress ? this.contractsFactory.getAmmContract(ammAddress) : undefined;
         const [marketInfo, bestBidTickAndApr, bestAskTickAndApr, ammState, ammImpliedRateBigInt, impliedRateData, marketConfig,] = await Promise.all([
             explorerContract.getMarketInfo(market.marketId),
@@ -722,13 +761,15 @@ class Exchange {
                 return cached.value;
             }
         }
-        const { skip, limit, isWhitelisted } = params ?? {};
-        const { data: getMarketsCalldataResponse } = await this.borosCoreSdk.markets.marketsControllerGetMarkets({
-            skip,
-            limit,
-            isWhitelisted,
+        const { limit, isWhitelisted } = params ?? {};
+        const { data: getMarketsCalldataResponse } = await this.openApiSdk.markets.marketsControllerListMarkets({
+            limit: limit ?? 200,
+            isUiWhitelisted: isWhitelisted,
         });
-        Exchange._getMarketsCache[cacheKey] = { value: getMarketsCalldataResponse, timestamp: now };
+        Exchange._getMarketsCache[cacheKey] = {
+            value: getMarketsCalldataResponse,
+            timestamp: now,
+        };
         return getMarketsCalldataResponse;
     }
     static _getMarketInfoCache = {};
@@ -743,7 +784,14 @@ class Exchange {
         }
         let data;
         try {
-            ({ data } = await this.borosCoreSdk.markets.marketsControllerGetMarketInfo(marketId));
+            const { data: byIds } = await this.openApiSdk.markets.marketsControllerGetMarketsByIds({
+                marketIds: String(marketId),
+            });
+            const market = byIds.results.find((m) => m.marketId === marketId) ?? byIds.results[0];
+            if (!market) {
+                throw new Error(`market ${marketId} not found (empty results)`);
+            }
+            data = market;
         }
         catch (e) {
             const reason = e instanceof Error ? e.message : String(e);
@@ -800,14 +848,18 @@ class Exchange {
             return marketIds.map((marketId) => ({ marketId, ...shared }));
         }
         if (responses.length === marketIds.length) {
-            return responses.map((response, index) => ({ marketId: marketIds[index], ...toResult(response) }));
+            return responses.map((response, index) => ({
+                marketId: marketIds[index],
+                ...toResult(response),
+            }));
         }
         throw new Error(`exitMarketsTyped: cannot attribute ${responses.length} bulk response(s) to ${marketIds.length} marketId(s); ` +
             `expected either 1 (batched) or ${marketIds.length} (per-input)`);
     }
     async getOrderBook(params) {
         const { marketId, tickSize } = params;
-        const { data: getOrderBookCalldataResponse } = await this.borosCoreSdk.orderBooks.orderBooksControllerGetOrderBooksByMarketId(marketId, {
+        const { data: getOrderBookCalldataResponse } = await this.openApiSdk.markets.marketsControllerGetOrderBook({
+            marketId,
             tickSize,
         });
         return getOrderBookCalldataResponse;
@@ -887,19 +939,17 @@ class Exchange {
         };
     }
     async getPnlLimitOrders(params) {
-        const { skip, limit, isActive, marketId, orderBy, userAddress, accountId, fromContract } = params ?? {};
+        const { limit, isActive, marketId, userAddress, accountId, fromContract } = params ?? {};
         if (fromContract) {
             return this.getPnlLimitOrdersFromContract(params);
         }
         const [{ data: getPnlLimitOrdersCalldataResponse }, blockNumber] = await Promise.all([
-            this.borosCoreSdk.pnL.pnlControllerGetLimitOrders({
-                userAddress: userAddress ?? this.root,
+            this.openApiSdk.accounts.accountsV2ControllerGetOrders({
+                root: userAddress ?? this.root,
                 accountId: accountId ?? this.accountId,
                 marketId,
-                skip,
                 limit,
                 isActive,
-                orderBy,
             }),
             this.publicClient.getBlockNumber(),
         ]);
@@ -909,23 +959,51 @@ class Exchange {
         };
     }
     async getCollaterals({ userAddress, accountId, }) {
-        const { data: getCollateralsCalldataResponse } = await this.borosCoreSdk.collaterals.collateralControllerGetAllCollateralSummary({
-            userAddress: userAddress ?? this.root,
-            accountId: accountId ?? this.accountId,
+        const { data: getCollateralsCalldataResponse } = await this.openApiSdk.accounts.accountsV2ControllerGetMarketAccInfosByRoot({
+            root: userAddress ?? this.root,
         });
         return getCollateralsCalldataResponse;
     }
     async getAssets() {
-        const { data: getAssetsCalldataResponse } = await this.borosCoreSdk.assets.assetsControllerGetAllAssets();
-        return getAssetsCalldataResponse;
+        const { data: getAssetsResponse } = await this.openApiSdk.assets.assetsControllerListAssets();
+        return { assets: getAssetsResponse.results };
     }
     async getAmmInfoByAmmId(ammId) {
-        const { data: getAmmInfoCalldataResponse } = await this.borosCoreSdk.amm.ammControllerGetAmmInfoByAmmId(ammId);
-        return getAmmInfoCalldataResponse;
+        const markets = await this.getMarkets();
+        const market = markets.results.find((m) => m.extConfig?.ammId === ammId);
+        if (!market) {
+            return undefined;
+        }
+        const { data: getAmmStatesResponse } = await this.openApiSdk.amm.ammv2ControllerGetAmmStates({
+            marketIds: String(market.marketId),
+        });
+        return getAmmStatesResponse.results.find((s) => s.ammId === ammId) ?? getAmmStatesResponse.results[0];
     }
     async getCumulativePnl(params) {
-        const { data: getCumulativeFeesCalldataResponse } = await this.borosCoreSdk.pnL.pnlControllerGetMarketAccCumulativePnl(params);
-        return getCumulativeFeesCalldataResponse;
+        const { root, accountId } = utils_1.MarketAccLib.unpack(params.marketAcc);
+        const { data: activePositions } = await this.openApiSdk.accounts.accountsV2ControllerGetActivePositions({
+            root,
+            accountId,
+        });
+        const position = activePositions.results.find((p) => p.marketId === params.marketId && p.marketAcc.toLowerCase() === params.marketAcc.toLowerCase());
+        if (position) {
+            return { cumulativeTradePnl: position.cumulativePnl };
+        }
+        let sum = 0n;
+        let resumeToken;
+        do {
+            const { data: events } = await this.openApiSdk.accounts.accountsV2ControllerGetPositionUpdateEvents({
+                marketAcc: params.marketAcc,
+                marketId: params.marketId,
+                limit: 2000,
+                resumeToken,
+            });
+            for (const event of events.results) {
+                sum += BigInt(event.pnl);
+            }
+            resumeToken = events.resumeToken ?? undefined;
+        } while (resumeToken);
+        return { cumulativeTradePnl: sum.toString() };
     }
     async approveAgentData(params) {
         const calldata = types_1.functionEncoder.approveAgent(params);