@bulletxyz/bullet-sdk 0.16.0-rc.0

package/dist/types/browser.d.ts

@@ -0,0 +1,12 @@
+export * from "./exchange";
+export * from "./orderbook";
+export * from "./utils";
+export * from "./types";
+export * from "./client";
+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";

package/dist/types/calc.d.ts

@@ -0,0 +1,23 @@
+import { Asset, AssetId, Side } from "./types";
+import { MarginConfig, OrderbookData, Pricing, UserAccount } from "./zod-types/rest";
+import { EquityType, MarginType } from "./bullet-wasm";
+export declare function calculateOrderbookMidpoint(orderbook: OrderbookData): number | undefined;
+export declare function calculateEntryPrice(asset: Asset, userAccount: UserAccount): number;
+export interface MarginContext {
+    pricing: Pricing;
+    margin_config: MarginConfig;
+}
+export declare function calculateTotalPerpUnrealizedPnl(userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateAccountEquity(equityType: EquityType, conservative: boolean, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateAccountLeverage(userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateAvailableMargin(marginType: MarginType, conservative: boolean, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateUsedMargin(marginType: MarginType, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateWithdrawableAmountOfAsset(assetId: AssetId, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateEstimatedLiquidationPrice(assetId: AssetId, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateLiquidationRiskPercentage(userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateMaxBorrowAmount(assetId: AssetId, userAccount: UserAccount, marginContext: MarginContext): number;
+export declare function calculateMaxOrderSize(assetId: AssetId, side: Side, price: number, reduceOnly: boolean, userAccount: UserAccount, marginContext: MarginContext, makerBook: OrderbookData, n_iterations?: number, error_tolerance?: number): number;
+export declare function simulateUsedMarginOnBorrow(assetId: AssetId, borrowAmount: number, userAccount: UserAccount, marginType: MarginType, marginContext: MarginContext): {
+    current: number;
+    new: number;
+};

package/dist/types/client.d.ts

@@ -0,0 +1,113 @@
+import { Transaction, TransactionResult } from "@sovereign-sdk/web3";
+import { ExchangeConnection } from "./exchange";
+import { Side, Asset, Network, Address, TokenId, CallMessage, TpslOrder, OrderType } from "./types";
+import { Wallet } from "./wallet";
+import { Connection } from "./connection";
+export interface TransactionOpts {
+    maxPriorityFeeBps: number;
+    maxFee: number;
+    gasLimit: number[] | null;
+    chainId: number;
+}
+export declare class Client {
+    connection: Connection;
+    exchange: ExchangeConnection;
+    address: Address;
+    private rollup;
+    private wallet;
+    private queue;
+    private generationOverride;
+    private constructor();
+    static create(network: Network, wallet: Wallet, txOpts?: TransactionOpts): Promise<Client>;
+    setGenerationOverride(generation: (() => number) | undefined): void;
+    getNonce(): Promise<import("@sovereign-sdk/web3").Dedup>;
+    getTokenBalance(tokenId: string): Promise<bigint>;
+    getUserAccount(): Promise<{
+        usdc_ledger: {
+            ledger: {
+                weights: {
+                    initial_liability_weight: number;
+                    maintenance_liability_weight: number;
+                    asset_weight: number;
+                };
+                asset: number;
+                liability: number;
+            };
+            unrealized_loss_borrow: number;
+            unsettled_perp_profit: number;
+        };
+        spot_ledgers: Map<any, {
+            weights: {
+                initial_liability_weight: number;
+                maintenance_liability_weight: number;
+                asset_weight: number;
+            };
+            asset: number;
+            liability: number;
+        }>;
+        perp_ledgers: Map<any, {
+            orders: {
+                size: number;
+                price: number;
+                side: "Bid" | "Ask";
+                order_id: number;
+                reduce_only: boolean;
+            }[];
+            position: {
+                size: number;
+                cost_of_trades: number;
+                realized_pnl: number;
+                cached_mark_price: number;
+                funding_payments_on_side: number;
+                funding_payments_on_position: number;
+                last_accum_funding_applied_per_lot: [number, number];
+            };
+            user_selected_max_leverage: number;
+            tpsls: {
+                side: "Bid" | "Ask";
+                tpsl_order_id: number;
+                order_price: number;
+                trigger_price: number;
+                trigger_direction: "GreaterThanOrEqual" | "LessThanOrEqual";
+                tpsl_price_condition: "Mark" | "Oracle" | "LastTrade";
+                active_size: number;
+                full_size: number;
+                order_type: "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
+                linked_tpsl_order_ids: number[];
+                parent_order_id?: number | undefined;
+            }[];
+        }>;
+    }>;
+    submitTransaction(runtimeCall: CallMessage): Promise<void | TransactionResult<Transaction<unknown>>>;
+    transfer(to: Address, amount: bigint, tokenId: TokenId): Promise<void | TransactionResult<Transaction<unknown>>>;
+    mint(to: Address, amount: bigint, tokenId: TokenId): Promise<void | TransactionResult<Transaction<unknown>>>;
+    setValue(value: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    deposit(asset: Asset, amount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    withdraw(asset: Asset, amount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    borrowSpot(asset: Asset, amount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    placeOrder(asset: Asset, price: number, size: number, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    placeTpsls(asset: Asset, tpslOrders: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    replaceOrder(asset: Asset, existingOrderId: number, existingSide: Side, price: number, size: number, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    cancelTpsl(tpslOrderId: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    cancelOrder(asset: Asset, orderId: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    cancelAllOrders(asset: Asset): Promise<void | TransactionResult<Transaction<unknown>>>;
+    updatePricing(pricing_updates: {
+        asset: Asset;
+        medianCexPrice: number;
+        oraclePrice: number;
+        diffEma: number;
+    }[], publishTimestamp?: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    updateAssetMaxLeverage(asset: Asset, maxLeverage: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    updatePremiumIndexes(assetIds: Asset[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    updateFunding(assetIds: Asset[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    applyFunding(addresses: Address[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    forceCancelOrders(address: Address): Promise<void | TransactionResult<Transaction<unknown>>>;
+    forceClosePositions(address: Address): Promise<void | TransactionResult<Transaction<unknown>>>;
+    liquidate(address: Address, positions?: {
+        asset: Asset;
+        size: number;
+    }[]): Promise<void | TransactionResult<Transaction<unknown>>>;
+    liquidateSpotLiability(address: Address, liabilityAssetId: Asset, collateralAssetId: Asset, liabilityAmount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    depositToUsdcPnlPool(amount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+    depositToInsuranceFund(amount: number): Promise<void | TransactionResult<Transaction<unknown>>>;
+}

package/dist/types/connection.d.ts

@@ -0,0 +1,12 @@
+import { TokenId, Address } from "./types";
+export declare class BaseConnection {
+    endpoint: string;
+    constructor(endpoint?: string);
+    protected fetchApiResource<T>(path: string, params?: Record<string, string>): Promise<T>;
+}
+export declare class Connection extends BaseConnection {
+    constructor(endpoint: string);
+    getNonce(address: Address): Promise<number>;
+    getTokenBalance(address: Address, token_id: TokenId): Promise<bigint>;
+    getTotalSupply(token_id: TokenId): Promise<bigint>;
+}

package/dist/types/constants.d.ts

@@ -0,0 +1,26 @@
+import { Network } from "./types";
+export declare const TOKEN_ADDRESSES: {
+    readonly GAS: "token_1nyl0e0yweragfsatygt24zmd8jrr2vqtvdfptzjhxkguz2xxx3vs0y07u7";
+    readonly USDC: "token_1zh04r2k3kk0jf3xzr8cfpcm6qntumxwdvglq75g2ynwcu7daca0qm9ccg3";
+    readonly SOL: "token_1djhak8xt5326dgq8urtean5xtsv6hawcn9cy9wvsdtptu2eqj40q0qjxr7";
+    readonly BTC: "token_1g09xywefypxxx5exvxuqy0v3c5a7jwpnq4kkl85wxu9pkhgnrtqszlm4n8";
+    readonly ETH: "token_1gxvm2vkwqw40q9d4djxhrk66mukgrhdtqljeq5qa7jm3ajyksmmqwervaa";
+    readonly DOGE: "token_1y0xpw76f4nlscy0g50j0n7vyt6cemza96p4gj7a3hj548a3tmcrspfjmr3";
+    readonly WIF: "token_1kwcvtrg0k4xllu8ylxukquckmlh273u8eufvqtx30e07gm8c3lpsuxv8j6";
+    readonly XRP: "token_1jezvz43ldt6vqgycch077qqa4m8e97enrqww93vzgqra7v7rhxpqz4j3rm";
+    readonly HYPE: "token_1caey4sxtejtmf3q0djxkuztx6up4f66dkudgmw2ev0slhafx09kqj9qxcf";
+    readonly ADA: "token_1xgppquwlmyxsp9ecrqtu2feucecjkcfryvm6uhxsegvqn494mywsm75spg";
+    readonly TRUMP: "token_1pmd3hja4m4jewfjfcxl3zt6vlmphyyh0nlr4cn3kfs0pkdqx4wwq76053k";
+    readonly SUI: "token_1kxyfvmf7mxr5256kx8cjrg6whvau54wpq30n5j805h64z0wyzzpswhmz36";
+    readonly JUP: "token_18saxwfuma39ks3gafmqtql5y57qpd6yh2r6s4uawak8c8pe6xrzspw5gtv";
+    readonly JTO: "token_1ecdw04ht4xh5hkhx37dshz7gpjgkrww56e53tqx4nkhmau55p5yswazeej";
+    readonly ENA: "token_120xgtxhl5uwp9p20k8yjd5plshr9fdvsn5afj7cqazh5csuduj8q9nmy42";
+    readonly BERA: "token_133zykxvsvq8u8eq2j67n63gc08dpc4zudrch9vl7028rahcvss3s42ywhs";
+    readonly TIA: "token_185jxgchq6kpxskn4eggjfeju3t4sjxxfxj5mx9dn6wgydud7mtys4glllf";
+    readonly ZEX: "token_1g3hhmzp0c358t0s2dxht8jqqrfnnrgerk423mgs4cxd96u8ux24stetj0c";
+};
+export declare const NETWORK_CONFIG: Record<Network, {
+    restEndpoint: string;
+    wsEndpoint: string;
+}>;
+export declare const GLOBAL_DEFAULT_MAX_LEVERAGE = 1000;

package/dist/types/error.d.ts

@@ -0,0 +1,8 @@
+export declare class ApiError extends Error {
+    readonly title: string;
+    readonly status: number;
+    readonly details: Record<string, unknown>;
+    private constructor();
+    static fromResponse(response: Response): Promise<ApiError>;
+    toString(): string;
+}

package/dist/types/exchange.d.ts

@@ -0,0 +1,23 @@
+import { BaseConnection } from "./connection";
+import { Orderbook } from "./orderbook";
+import { AssetId, Network } from "./types";
+import { Order, OrderbookData, EnrichedBorrowLendMarket, Pricing, PerpMarket, MarginConfig, UsdcPnlPool, UsdcInsuranceFund, UserAccount } from "./zod-types/rest";
+export declare class ExchangeConnection extends BaseConnection {
+    private wsManager;
+    constructor(network: Network);
+    getValue(): Promise<number | null>;
+    getOrder(order_id: number): Promise<Order | null>;
+    getOrderbookData(asset_id: number): Promise<OrderbookData | null>;
+    getUserAccountAddresses(start?: number, limit?: number): Promise<string[]>;
+    getUserAccounts(addresses: string[]): Promise<UserAccount[]>;
+    getPricing(): Promise<Pricing | null>;
+    getUsdcPnlPool(): Promise<UsdcPnlPool | null>;
+    getUsdcInsuranceFund(): Promise<UsdcInsuranceFund | null>;
+    getEnrichedBorrowLendMarket(asset_id: number): Promise<EnrichedBorrowLendMarket | null>;
+    getPerpMarket(asset_id: number): Promise<PerpMarket | null>;
+    getMarginConfig(): Promise<MarginConfig | null>;
+    getPerpAssets(): Promise<Map<AssetId, string>>;
+    getBorrowLendAssets(): Promise<Map<AssetId, string>>;
+    subscribeOrderbook(assetId: number): AsyncIterable<Orderbook>;
+    unsubscribeOrderbook(assetId: number): Promise<void>;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./exchange";
+export * from "./orderbook";
+export * from "./utils";
+export * from "./types";
+export * from "./wallet";
+export * from "./client";
+export * from "./zod-types/rest";
+export * from "./zod-types/ws";
+export * from "./zod-types/wasm";
+export * from "./constants";
+export * from "./wallet/nodeWallet";
+export * from "./calc";
+export * from "./error";

package/dist/types/orderbook.d.ts

@@ -0,0 +1,22 @@
+import { Asset } from "./types";
+import { OrderbookData } from "./zod-types/rest";
+import { OrderbookUpdate } from "./zod-types/ws";
+type Price = number;
+type TotalSize = number;
+type OrderbookLevel = [Price, TotalSize];
+export declare class Orderbook {
+    bids: Map<Price, TotalSize>;
+    asks: Map<Price, TotalSize>;
+    asset: Asset;
+    lastUpdated: number;
+    constructor(assetId: number, snapshot?: OrderbookUpdate);
+    protected updateBid(price: number, size: number): void;
+    protected updateAsk(price: number, size: number): void;
+    applyDelta(delta: OrderbookUpdate): void;
+    getBids(levels?: number): OrderbookLevel[];
+    getAsks(levels?: number): OrderbookLevel[];
+    static fromOrderbookData(orderbook: OrderbookData): Orderbook;
+    toDisplay(levels?: number): string;
+    setLastUpdated(ts: number): void;
+}
+export {};

package/dist/types/test/wasm.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,52 @@
+import { MarginType } from "./bullet-wasm";
+export { MarginType };
+export type CallMessage = {
+    [module: string]: {
+        [instruction: string]: string | number | object;
+    };
+};
+export type PrivateKey = string;
+export type PublicKey = string;
+export type Address = string;
+export type TokenId = string;
+export type AssetId = number;
+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 type Side = "Bid" | "Ask";
+export type TriggerDirection = "GreaterThanOrEqual" | "LessThanOrEqual";
+export type TpslPriceCondition = "Mark" | "Oracle" | "LastTrade";
+export type OrderType = "Limit" | "PostOnly" | "FillOrKill" | "ImmediateOrCancel" | "PostOnlySlide" | "PostOnlyFront";
+export type Network = "Localnet" | "Staging" | "Testnet" | "Mainnet";
+export type TpslOrder = {
+    orderPrice: number;
+    triggerPrice: number;
+    triggerDirection: TriggerDirection;
+    tpslPriceCondition: TpslPriceCondition;
+    size: number;
+    orderType: OrderType;
+};
+export declare class BulletError extends Error {
+    originalError?: Error | undefined;
+    code: string;
+    shortMessage: string;
+    verboseMessage: string;
+    constructor(code: string, shortMessage: string, verboseMessage: string, originalError?: Error | undefined);
+    static fromModuleError(error: Error): Error;
+}

package/dist/types/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function bytesToHex(bytes: Uint8Array): string;
+export declare function hexToBytes(hex: string): Uint8Array;
+export declare function hexToBase64(hex: string): string;
+export declare function hexToBase58(hex: string): string;
+export declare function base58ToBytes(base58: string): Uint8Array;
+export declare function base58ToHex(base58: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function isNode(): boolean;

package/dist/types/wallet/index.d.ts

@@ -0,0 +1 @@
+export * from "./wallet";

package/dist/types/wallet/nodeWallet.d.ts

@@ -0,0 +1,12 @@
+import { PrivateKey, PublicKey } from "../types";
+import { Wallet } from "./wallet";
+import { Signer } from "@sovereign-sdk/signers";
+export declare class NodeWallet extends Wallet {
+    private privateKey;
+    chainId: number;
+    constructor(privateKey: PrivateKey, publicKey: PublicKey, chainId?: number);
+    static fromPrivateKeyBytes(privateKeyBytes: Uint8Array): Promise<NodeWallet>;
+    static fromLocalSolanaWallet(filePath?: string): NodeWallet;
+    static fromLocalSovWallet(filePath: string): Promise<NodeWallet>;
+    getSigner(chainHash: Uint8Array): Signer;
+}

package/dist/types/wallet/wallet.d.ts

@@ -0,0 +1,9 @@
+import { PublicKey, Address } from "../types";
+import { Signer } from "@sovereign-sdk/signers";
+export declare abstract class Wallet {
+    address: Address;
+    publicKey: PublicKey;
+    chainId: number;
+    constructor(publicKey: PublicKey, chainId?: number);
+    abstract getSigner(chainHash: Uint8Array): Signer;
+}

package/dist/types/websocket.d.ts

@@ -0,0 +1,23 @@
+import { Orderbook } from "./orderbook";
+export declare class WebSocketManager {
+    private socket;
+    private orderbooks;
+    private isConnected;
+    private heartbeatInterval;
+    private lastUpdateIds;
+    private url;
+    private reconnectAttempts;
+    private readonly maxReconnectAttempts;
+    private readonly reconnectDelay;
+    private eventEmitter;
+    constructor(url: string);
+    private connect;
+    private handleReconnect;
+    private handleMessage;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private sendSubscription;
+    sendMessage(message: string): void;
+    subscribeOrderbook(assetId: number): AsyncIterable<Orderbook>;
+    unsubscribeOrderbook(assetId: number): Promise<void>;
+}

package/dist/types/zod-types/index.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export declare const Decimal: z.ZodNumber;
+export declare const AssetId: z.ZodNumber;
+export declare const Amount: z.ZodEffects<z.ZodBigInt, bigint, bigint>;
+export declare const createJsonMap: <K extends z.ZodTypeAny, V extends z.ZodTypeAny>(valueSchema: V) => z.ZodEffects<z.ZodRecord<z.ZodString, V>, Map<z.infer<K>, z.infer<V>>>;