@bulletxyz/bullet-sdk 0.25.4 → 0.26.0-rc.1

package/dist/types/browser.d.ts

@@ -7,7 +7,6 @@ export * from "./zod-types/rest";
 export * from "./zod-types/ws";
 export * from "./zod-types/wasm";
 export * from "./constants";
-export * from "./calc";
 export * from "./error";
 export { Wallet } from "./wallet";
 export { Connection } from "./connection";

package/dist/types/bullet-wasm/index.d.ts

@@ -14,7 +14,7 @@ export class BulletWasm {
   static calculate_account_equity(user_account: any, conservative: boolean, equity_type: EquityType, margin_calculation_state: any): string;
   static calculate_account_leverage(user_account: any, margin_calculation_state: any): string;
   static calculate_available_margin(user_account: any, conservative: boolean, margin_type: MarginType, margin_calculation_state: any): string;
-  static calculate_used_margin(user_account: any, margin_type: MarginType, margin_calculation_state: any): string;
+  static calculate_used_margin(user_account: any, withdrawal: boolean, margin_type: MarginType, margin_calculation_state: any): string;
   static calculate_withdrawable_amount_of_asset(user_account: any, asset_id: number, margin_calculation_state: any): string;
   static calculate_estimated_liquidation_price(user_account: any, market_id: number, base_asset_id: number, margin_calculation_state: any): string;
   static calculate_liquidation_risk_percentage(user_account: any, margin_calculation_state: any): string;

package/dist/types/client.d.ts

@@ -4,7 +4,7 @@ import { Connection } from "./connection";
 import { type Endpoints } from "./constants";
 import { ExchangeConnection } from "./exchange";
 import type { RuntimeCall } from "./rollupTypes";
-import { type Address, type Asset, type MarkPriceUpdateArgs, type Market, type Network, type OraclePriceUpdateArgs, type PlaceOrderArgs, type PlacePositionTpslArgs, type TokenId } from "./types";
+import { type Address, type AssetName, type MarkPriceUpdateArgs, type MarketName, type Network, type OraclePriceUpdateArgs, type PlaceOrderArgs, type PlacePositionTpslArgs, type TokenId } from "./types";
 import type { Wallet } from "./wallet";
 export interface TransactionOpts {
     maxPriorityFeeBps: number;
@@ -12,7 +12,7 @@ export interface TransactionOpts {
     gasLimit: number[] | null;
     chainId: number;
 }
-type ReplaceOrderOptions = {
+type AmendOrderOptions = {
     existingOrderId: bigint;
     existingClientOrderId?: never;
     placeOrderArgs: PlaceOrderArgs;
@@ -111,30 +111,33 @@ export declare class Client {
     submitTransaction(runtimeCall: RuntimeCall): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     transfer(to: Address, amount: bigint, tokenId: TokenId): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     mint(to: Address, amount: bigint, tokenId: TokenId): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    deposit(asset: Asset, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    withdraw(asset: Asset, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    borrowSpot(asset: Asset, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    deposit(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    withdraw(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    borrowSpot(asset: AssetName, amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     placeOrder(placeOrderArgs: PlaceOrderArgs): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    placeTpslsForMarket(market: Market, tpslOrders: PlacePositionTpslArgs): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    replaceOrder(options: ReplaceOrderOptions): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    createPositionTpsl(market: MarketName, tpslOrders: PlacePositionTpslArgs): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    amendOrder(options: AmendOrderOptions): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     cancelTpsl(tpslOrderId: bigint): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     cancelOrder(orderId?: bigint, clientOrderId?: bigint): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    cancelAllOrdersForMarket(market: Market): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    cancelAllOrdersForMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     updateOraclePrices(pricesToUpdate: OraclePriceUpdateArgs[], publishTimestamp?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     updateMarkPrices(pricesToUpdate: MarkPriceUpdateArgs[], publishTimestamp?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    updateMaxLeverageForMarket(market: Market, maxLeverage: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    updatePremiumIndexes(marketIds: Market[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    processTpslBufferForMarket(market: Market): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    updateFunding(marketIds: Market[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updateMaxLeverageForMarket(market: MarketName, maxLeverage: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updatePremiumIndexes(markets: MarketName[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    processTpslBufferForMarket(market: MarketName): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updateFunding(markets: MarketName[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     applyFunding(addresses: Address[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     forceCancelOrders(address: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     forceClosePositions(address: Address): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     liquidatePerpPositions(address: Address, positions?: {
-        market: Market;
+        market: MarketName;
         size: Decimal;
     }[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
-    liquidateSpotLiability(address: Address, liabilityAssetId: Asset, collateralAssetId: Asset, liabilityAmount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    liquidateSpotLiability(address: Address, liabilityAssetId: AssetName, collateralAssetId: AssetName, liabilityAmount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     depositToUsdcPnlPool(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     depositToInsuranceFund(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    initAssetMetadata(asset_id: number, assetName: string, tokenId: TokenId, decimals: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    initBorrowLendMarket(asset: AssetName, optimalUtilisationRate: Decimal, minBorrowRate: Decimal, maxBorrowRate: Decimal, optimalBorrowRate: Decimal, assetWeight: Decimal, initialLiabilityWeight: Decimal, maintenanceLiabilityWeight: Decimal, depositLimit: Decimal, borrowLimit: Decimal, liquidationRewardRatio: Decimal, liabilityLiquidationLimitRatio: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updateBorrowLendMarket(asset: AssetName, optimalUtilisationRate: Decimal | null, minBorrowRate: Decimal | null, maxBorrowRate: Decimal | null, optimalBorrowRate: Decimal | null, assetWeight: Decimal | null, initialLiabilityWeight: Decimal | null, maintenanceLiabilityWeight: Decimal | null, depositLimit: Decimal | null, borrowLimit: Decimal | null, liquidationRewardRatio: Decimal | null, liabilityLiquidationLimitRatio: Decimal | null): Promise<TransactionResult<Transaction<RuntimeCall>>>;
 }
 export {};

package/dist/types/exchange.d.ts

@@ -1,19 +1,35 @@
+import Decimal from "decimal.js";
+import { type EquityType, type MarginType } from "./bullet-wasm";
 import { BaseConnection } from "./connection";
 import { type Endpoints } from "./constants";
 import type { Orderbook } from "./orderbook";
-import type { Address, Market, Network } from "./types";
+import type { Address, AssetName, MarketName, Network } from "./types";
+import type { OrderType, PlaceOrderArgs, Side } from "./types";
 import { type AccountAddresses, type AssetRegistry, type BorrowLendMarkets, type GlobalParameters, type MarginConfig, type MarketRegistry, type OraclePrices, type Order, type OrderbookL2, type PerpMarket, type PerpPrices, type TpslOrderIdsToExecute, type UsdcInsuranceFund, type UsdcPnlPool, type UserAccount } from "./zod-types/rest";
 export declare class ExchangeConnection extends BaseConnection {
     private wsManager?;
+    private assetRegistry?;
+    private assetRegistryReverse?;
+    private marketRegistry?;
+    private marketRegistryReverse?;
     private constructor();
-    static fromEndpoints(endpoints: Endpoints): ExchangeConnection;
-    static fromNetwork(network: Network): ExchangeConnection;
-    static fromRestUrl(restUrl: string): ExchangeConnection;
-    getOrder(order_id: bigint): Promise<Order | null>;
+    static fromEndpoints(endpoints: Endpoints): Promise<ExchangeConnection>;
+    static fromNetwork(network: Network): Promise<ExchangeConnection>;
+    static fromRestUrl(restUrl: string): Promise<ExchangeConnection>;
+    private initializeRegistries;
+    private initializeAssetRegistry;
+    private initializeMarketRegistry;
+    getOrder(orderId: bigint): Promise<Order | null>;
     getMarketRegistry(): Promise<MarketRegistry | null>;
     getAssetRegistry(): Promise<AssetRegistry | null>;
-    getOrderbookL2(market: Market, levels?: number): Promise<OrderbookL2>;
-    getOrderbookL2s(markets: Market[], levels?: number): Promise<Map<Market, OrderbookL2>>;
+    private getAssetMapping;
+    private getMarketMapping;
+    getAssetId(asset: AssetName): number;
+    getAssetName(assetId: number): AssetName;
+    getMarketId(market: MarketName): number;
+    getMarketName(marketId: number): string;
+    getOrderbookL2(market: MarketName, levels?: number): Promise<OrderbookL2>;
+    getOrderbookL2s(markets: MarketName[], levels?: number): Promise<Map<number, OrderbookL2>>;
     getUserAccountAddresses(offset?: number, limit?: number): Promise<AccountAddresses>;
     getUserAccount(address: Address): Promise<UserAccount>;
     getUserAccounts(addresses: Address[]): Promise<Map<string, UserAccount>>;
@@ -22,12 +38,121 @@ export declare class ExchangeConnection extends BaseConnection {
     getUsdcPnlPool(): Promise<UsdcPnlPool | null>;
     getUsdcInsuranceFund(): Promise<UsdcInsuranceFund | null>;
     getBorrowLendMarkets(): Promise<BorrowLendMarkets>;
-    getPerpMarket(market: Market): Promise<PerpMarket>;
-    getPerpMarkets(markets: Market[]): Promise<Map<Market, PerpMarket>>;
+    getPerpMarket(market: MarketName): Promise<PerpMarket>;
+    getPerpMarkets(markets: MarketName[]): Promise<Map<number, PerpMarket>>;
     getMarginConfig(): Promise<MarginConfig | null>;
-    getTpslOrderIdsToExecute(market: Market): Promise<TpslOrderIdsToExecute | null>;
+    getTpslOrderIdsToExecute(market: MarketName): Promise<TpslOrderIdsToExecute | null>;
     getGlobalParameters(): Promise<GlobalParameters | null>;
+    calculateOrderbookMidpoint(orderbook: OrderbookL2): Decimal | undefined;
+    calculateEntryPrice(market: MarketName, userAccount: UserAccount): Promise<Decimal>;
+    calculateTotalPerpUnrealizedPnl(userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateAccountEquity(equityType: EquityType, conservative: boolean, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateAccountLeverage(userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateAvailableMargin(marginType: MarginType, conservative: boolean, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateUsedMargin(withdrawal: boolean, marginType: MarginType, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateWithdrawableAmountOfAsset(asset: AssetName, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Promise<Decimal>;
+    calculateEstimatedLiquidationPrice(market: MarketName, asset: AssetName, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Promise<Decimal>;
+    calculateLiquidationRiskPercentage(userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateForceCancelRiskPercentage(userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Decimal;
+    calculateMaxBorrowAmount(asset: AssetName, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Promise<Decimal>;
+    calculateMaxOrderSize(market: MarketName, price: Decimal, side: Side, order_type: OrderType, reduce_only: boolean, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }, orderbook: OrderbookL2, n_iterations?: number, error_tolerance?: Decimal): Promise<Decimal>;
+    simulateUsedMarginOnBorrow(asset: AssetName, borrowAmount: Decimal, userAccount: UserAccount, marginType: MarginType, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Promise<{
+        current: Decimal;
+        updated: Decimal;
+    }>;
+    simulateUsedMarginOnOrder(placeOrderArgs: PlaceOrderArgs, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }, orderbook: OrderbookL2): Promise<{
+        current: Decimal;
+        updated: Decimal;
+    }>;
+    simulateEstimatedLiquidationPriceOnOrder(placeOrderArgs: PlaceOrderArgs, baseAsset: AssetName, userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }, orderbook: OrderbookL2): Promise<{
+        current: Decimal;
+        updated: Decimal;
+    }>;
+    calculatePositionsAdditionalMetadata(userAccount: UserAccount, MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }): Promise<Map<number, {
+        projected_funding_payment: Decimal;
+        unrealized_pnl: Decimal;
+        liquidation_price: Decimal;
+        liquidation_risk_percentage: Decimal;
+        max_leverage_to_use: number;
+    }>>;
+    calculateBorrowLendMarketAdditionalMetadata(borrowLendMarkets: BorrowLendMarkets, asset: AssetName): Promise<{
+        utilisation_rate: Decimal;
+        current_deposit_rate: Decimal;
+        current_borrow_rate: Decimal;
+    }>;
+    calculateAccountSummaryBatch(userAccounts: UserAccount[], MarginCalculationState: {
+        oracle_prices: OraclePrices;
+        perp_prices: PerpPrices;
+        margin_config: MarginConfig;
+    }, useWeightedEquity?: boolean): Promise<{
+        address: string;
+        unrealized_pnl: Decimal;
+        equity: Decimal;
+        available_initial_margin: Decimal;
+        available_maintenance_margin: Decimal;
+        leverage: Decimal;
+    }[]>;
     private getWebSocketManager;
-    subscribeOrderbook(marketId: Market): AsyncIterable<Orderbook>;
-    unsubscribeOrderbook(marketId: Market): Promise<void>;
+    subscribeOrderbook(market: MarketName): AsyncIterable<Orderbook>;
+    unsubscribeOrderbook(market: MarketName): Promise<void>;
 }

package/dist/types/index.d.ts

@@ -9,6 +9,5 @@ export * from "./zod-types/ws";
 export * from "./zod-types/wasm";
 export * from "./constants";
 export * from "./wallet/nodeWallet";
-export * from "./calc";
 export * from "./error";
 export { Connection } from "./connection";

package/dist/types/orderbook.d.ts

@@ -1,12 +1,11 @@
 import Decimal from "decimal.js";
-import type { Market } from "./types";
 import type { OrderbookL2, PriceLevel } from "./zod-types/rest";
 import type { OrderbookUpdate } from "./zod-types/ws";
 type Size = Decimal;
 export declare class Orderbook {
     bids: Map<string, Size>;
     asks: Map<string, Size>;
-    market: Market;
+    marketId: number;
     lastUpdated: number;
     constructor(marketId: number, snapshot?: OrderbookUpdate);
     protected updateBid(price: string, size: Size): void;

package/dist/types/rollupTypes.d.ts

@@ -22,6 +22,27 @@ type BankCallMessage = {
         };
     };
 };
+type WarpCallMessage = {
+    Register: {
+        admin: {
+            InsecureOwner: Address;
+        };
+        ism: {
+            MessageIdMultisig: {
+                threshold: number;
+                validators: string[];
+            };
+        };
+        token_source: {
+            Synthetic: {
+                remote_token_id: string;
+                local_decimals: number;
+                remote_decimals: number;
+            };
+        };
+        remote_routers: [number, string][];
+    };
+};
 type TriggerOrderArgs = {
     order_price: number;
     trigger_price: number;
@@ -65,11 +86,11 @@ type ExchangeCallMessage = {
             tpsl: PendingTriggerOrderArgs | null;
         };
     };
-    place_tpsl_for_market: {
+    create_position_tpsl: {
         market_id: MarketId;
         tpsl: PlacePositionTpslArgs;
     };
-    replace_order: {
+    amend_order: {
         existing_order_id: string | null;
         existing_client_order_id: string | null;
         order_args: {
@@ -149,9 +170,50 @@ type ExchangeCallMessage = {
     deposit_to_insurance_fund: {
         usdc_amount: number;
     };
+    init_asset_metadata: {
+        args: {
+            asset_id: AssetId;
+            asset_name: string;
+            token_id: TokenId;
+            decimals: number;
+        };
+    };
+    init_borrow_lend_market: {
+        args: {
+            asset_id: AssetId;
+            optimal_utilisation_rate: number;
+            min_borrow_rate: number;
+            max_borrow_rate: number;
+            optimal_borrow_rate: number;
+            asset_weight: number;
+            initial_liability_weight: number;
+            maintenance_liability_weight: number;
+            deposit_limit: number;
+            borrow_limit: number;
+            liquidation_reward_ratio: number;
+            liability_liquidation_limit_ratio: number;
+        };
+    };
+    update_borrow_lend_market: {
+        args: {
+            asset_id: AssetId;
+            optimal_utilisation_rate: number | null;
+            min_borrow_rate: number | null;
+            max_borrow_rate: number | null;
+            optimal_borrow_rate: number | null;
+            asset_weight: number | null;
+            initial_liability_weight: number | null;
+            maintenance_liability_weight: number | null;
+            deposit_limit: number | null;
+            borrow_limit: number | null;
+            liquidation_reward_ratio: number | null;
+            liability_liquidation_limit_ratio: number | null;
+        };
+    };
 };
 export type RuntimeCall = ExactlyOne<{
     exchange: ExactlyOne<ExchangeCallMessage>;
     bank: ExactlyOne<BankCallMessage>;
+    warp: ExactlyOne<WarpCallMessage>;
 }>;
 export {};

package/dist/types/types.d.ts

@@ -3,47 +3,12 @@ export type PrivateKey = string;
 export type PublicKey = string;
 export type Address = string;
 export type TokenId = string;
+export type AssetName = string;
+export type MarketName = string;
 export type AssetId = number;
 export type MarketId = number;
 export type OrderId = bigint;
 export type ClientOrderId = bigint;
-export declare enum Asset {
-    USDC = 0,
-    SOL = 1,
-    BTC = 2,
-    ETH = 3,
-    DOGE = 4,
-    WIF = 5,
-    XRP = 6,
-    HYPE = 7,
-    ADA = 8,
-    TRUMP = 9,
-    SUI = 10,
-    JUP = 11,
-    JTO = 12,
-    ENA = 13,
-    BERA = 14,
-    TIA = 15,
-    ZEX = 16
-}
-export declare enum Market {
-    SOL_USD = 0,
-    BTC_USD = 1,
-    ETH_USD = 2,
-    DOGE_USD = 3,
-    WIF_USD = 4,
-    XRP_USD = 5,
-    HYPE_USD = 6,
-    ADA_USD = 7,
-    TRUMP_USD = 8,
-    SUI_USD = 9,
-    JUP_USD = 10,
-    JTO_USD = 11,
-    ENA_USD = 12,
-    BERA_USD = 13,
-    TIA_USD = 14,
-    ZEX_USD = 15
-}
 export type MarketKind = "Perp" | "Spot";
 export type Side = "Bid" | "Ask";
 export type TriggerDirection = "GreaterThanOrEqual" | "LessThanOrEqual";
@@ -53,7 +18,7 @@ export type MarginType = "Initial" | "Maintenance";
 export type EquityType = "Unweighted" | "WeightedInitial" | "WeightedMaintenance";
 export type Network = "Localnet" | "Staging" | "Testnet" | "Mainnet";
 export type PlaceOrderArgs = {
-    marketId: MarketId;
+    market: MarketName;
     price: Decimal;
     size: Decimal;
     side: Side;
@@ -63,11 +28,11 @@ export type PlaceOrderArgs = {
     tpsl?: PendingTriggerOrderArgs;
 };
 export type OraclePriceUpdateArgs = {
-    assetId: AssetId;
+    asset: AssetName;
     oraclePrice: Decimal;
 };
 export type MarkPriceUpdateArgs = {
-    marketId: MarketId;
+    market: MarketName;
     medianCexPrice: Decimal;
     diffEma: Decimal;
 };

package/dist/types/websocket.d.ts

@@ -1,5 +1,5 @@
 import { Orderbook } from "./orderbook";
-import type { AssetId } from "./types";
+import type { MarketId } from "./types";
 export declare class WebSocketManager {
     private socket;
     private orderbooks;
@@ -19,6 +19,6 @@ export declare class WebSocketManager {
     private stopHeartbeat;
     private sendSubscription;
     sendMessage(message: string): void;
-    subscribeOrderbook(assetId: AssetId): AsyncIterable<Orderbook>;
-    unsubscribeOrderbook(assetId: AssetId): Promise<void>;
+    subscribeOrderbook(marketId: MarketId): AsyncIterable<Orderbook>;
+    unsubscribeOrderbook(marketId: MarketId): Promise<void>;
 }

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "git+https://github.com/zetamarkets/bullet-sdk.git"
   },
-  "version": "0.25.4",
+  "version": "0.26.0-rc.1",
   "description": "Bullet SDK",
   "author": "@bulletxyz",
   "license": "Apache-2.0",
@@ -31,7 +31,7 @@
     "build:js": "node build.mjs",
     "clean": "rm -rf dist",
     "build": "pnpm clean && pnpm build:types && pnpm build:js",
-    "dev": "tsx --experimental-wasm-modules examples/test.ts",
+    "dev": "tsx --experimental-wasm-modules scripts/test.ts",
     "package": "pnpm build && pnpm pack",
     "prepublishOnly": "pnpm build",
     "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",

package/dist/types/calc.d.ts

@@ -1,54 +0,0 @@
-import Decimal from "decimal.js";
-import { type EquityType, type MarginType } from "./bullet-wasm";
-import type { Asset, Market, OrderType, PlaceOrderArgs, Side } from "./types";
-import type { BorrowLendMarkets, MarginConfig, OraclePrices, OrderbookL2, PerpPrices, UserAccount } from "./zod-types/rest";
-export declare function calculateOrderbookMidpoint(orderbook: OrderbookL2): Decimal | undefined;
-export declare function calculateEntryPrice(market: Market, userAccount: UserAccount): Decimal;
-export interface MarginCalculationState {
-    oracle_prices: OraclePrices;
-    perp_prices: PerpPrices;
-    margin_config: MarginConfig;
-}
-export declare function calculateTotalPerpUnrealizedPnl(userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateAccountEquity(equityType: EquityType, conservative: boolean, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateAccountLeverage(userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateAvailableMargin(marginType: MarginType, conservative: boolean, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateUsedMargin(marginType: MarginType, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateWithdrawableAmountOfAsset(asset: Asset, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateEstimatedLiquidationPrice(market: Market, asset: Asset, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateLiquidationRiskPercentage(userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateForceCancelRiskPercentage(userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateMaxBorrowAmount(asset: Asset, userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Decimal;
-export declare function calculateMaxOrderSize(market: Market, price: Decimal, side: Side, order_type: OrderType, reduce_only: boolean, userAccount: UserAccount, MarginCalculationState: MarginCalculationState, orderbook: OrderbookL2, n_iterations?: number, error_tolerance?: Decimal): Decimal;
-export declare function simulateUsedMarginOnBorrow(asset: Asset, borrowAmount: Decimal, userAccount: UserAccount, marginType: MarginType, MarginCalculationState: MarginCalculationState): {
-    current: Decimal;
-    updated: Decimal;
-};
-export declare function simulateUsedMarginOnOrder(placeOrderArgs: PlaceOrderArgs, userAccount: UserAccount, MarginCalculationState: MarginCalculationState, orderbook: OrderbookL2): {
-    current: Decimal;
-    updated: Decimal;
-};
-export declare function simulateEstimatedLiquidationPriceOnOrder(placeOrderArgs: PlaceOrderArgs, baseAsset: Asset, userAccount: UserAccount, MarginCalculationState: MarginCalculationState, orderbook: OrderbookL2): {
-    current: Decimal;
-    updated: Decimal;
-};
-export declare function calculatePositionsAdditionalMetadata(userAccount: UserAccount, MarginCalculationState: MarginCalculationState): Map<number, {
-    projected_funding_payment: Decimal;
-    unrealized_pnl: Decimal;
-    liquidation_price: Decimal;
-    liquidation_risk_percentage: Decimal;
-    max_leverage_to_use: number;
-}>;
-export declare function calculateBorrowLendMarketAdditionalMetadata(borrowLendMarkets: BorrowLendMarkets, asset: Asset): {
-    utilisation_rate: Decimal;
-    current_deposit_rate: Decimal;
-    current_borrow_rate: Decimal;
-};
-export declare function calculateAccountSummaryBatch(userAccounts: UserAccount[], MarginCalculationState: MarginCalculationState, useWeightedEquity?: boolean): {
-    address: string;
-    unrealized_pnl: Decimal;
-    equity: Decimal;
-    available_initial_margin: Decimal;
-    available_maintenance_margin: Decimal;
-    leverage: Decimal;
-}[];