@bulletxyz/bullet-sdk 0.17.3-rc.6 → 0.17.4-rc.0

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

@@ -0,0 +1,37 @@
+/* tslint:disable */
+/* eslint-disable */
+export enum EquityType {
+  Unweighted = 0,
+  WeightedInitial = 1,
+  WeightedMaintenance = 2,
+}
+export enum MarginType {
+  Initial = 0,
+  Maintenance = 1,
+}
+export enum Side {
+  Bid = 0,
+  Ask = 1,
+}
+export class BulletWasm {
+  free(): void;
+  constructor();
+  static dummy(a: number): number;
+  static convert_token_id_to_bytes(token_id: string): Uint8Array;
+  static convert_rust_decimal_to_json(decimal_str: string): any;
+  static calculate_total_perp_unrealized_pnl(user_account: any, margin_context: any): string;
+  static calculate_account_equity(user_account: any, conservative: boolean, equity_type: EquityType, margin_context: any): string;
+  static calculate_account_leverage(user_account: any, margin_context: any): string;
+  static calculate_available_margin(user_account: any, conservative: boolean, margin_type: MarginType, margin_context: any): string;
+  static calculate_used_margin(user_account: any, margin_type: MarginType, margin_context: any): string;
+  static calculate_withdrawable_amount_of_asset(user_account: any, asset_id: number, margin_context: any): string;
+  static calculate_estimated_liquidation_price(user_account: any, asset_id: number, margin_context: any): string;
+  static calculate_liquidation_risk_percentage(user_account: any, margin_context: any): string;
+  static calculate_force_close_risk_percentage(user_account: any, margin_context: any): string;
+  static calculate_max_borrow_amount(asset_id: number, user_account: any, margin_context: any): string;
+  static calculate_max_order_size(user_account: any, asset_id: number, side: Side, price: string, reduce_only: boolean, margin_context: any, maker_book: any, n_iterations: number, error_tolerance: string): string;
+  static simulate_used_margin_on_borrow(asset_id: number, borrow_amount: string, user_account: any, margin_type: MarginType, margin_context: any): any;
+  static simulate_used_margin_on_order(_user_account: any, _margin_context: any): string;
+  static calculate_positions_additional_metadata(user_account: any, margin_context: any, funding_parameters: any): any;
+  static calculate_borrow_lend_additional_metadata(borrow_lend_market: any): any;
+}

package/dist/types/calc.d.ts

@@ -1,7 +1,7 @@
-import { Asset, AssetId, Side } from "./types";
-import { BorrowLendMarket, MarginConfig, OrderbookData, PerpMarket, Pricing, UserAccount } from "./zod-types/rest";
-import { EquityType, MarginType } from "./bullet-wasm";
 import Decimal from "decimal.js";
+import { type EquityType, type MarginType } from "./bullet-wasm";
+import type { Asset, AssetId, Side } from "./types";
+import type { BorrowLendMarket, MarginConfig, OrderbookData, PerpMarket, Pricing, UserAccount } from "./zod-types/rest";
 export declare function calculateOrderbookMidpoint(orderbook: OrderbookData): Decimal | undefined;
 export declare function calculateEntryPrice(asset: Asset, userAccount: UserAccount): Decimal;
 export interface MarginContext {

package/dist/types/client.d.ts

@@ -1,9 +1,10 @@
-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 { type Transaction, type TransactionResult } from "@sovereign-sdk/web3";
+import type Decimal from "decimal.js";
 import { Connection } from "./connection";
-import Decimal from "decimal.js";
+import { ExchangeConnection } from "./exchange";
+import type { RuntimeCall } from "./rollupTypes";
+import { type Address, type Asset, type Network, type OrderType, type Side, type TokenId, type TpslOrder } from "./types";
+import type { Wallet } from "./wallet";
 export interface TransactionOpts {
     maxPriorityFeeBps: number;
     maxFee: number;
@@ -53,6 +54,9 @@ export declare class Client {
                 side: "Bid" | "Ask";
                 order_id: bigint;
                 reduce_only: boolean;
+                filled_size: Decimal;
+                average_filled_price: Decimal;
+                tpsl_order_ids: bigint[];
             }[];
             position: {
                 size: Decimal;
@@ -79,36 +83,36 @@ export declare class Client {
             }[];
         }>;
     }>;
-    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: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
-    withdraw(asset: Asset, amount: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
-    borrowSpot(asset: Asset, amount: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
-    placeOrder(asset: Asset, price: Decimal, size: Decimal, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
-    placeTpsls(asset: Asset, tpslOrders: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
-    replaceOrder(existingOrderId: bigint, asset: Asset, price: Decimal, size: Decimal, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<void | TransactionResult<Transaction<unknown>>>;
-    cancelTpsl(tpslOrderId: bigint): Promise<void | TransactionResult<Transaction<unknown>>>;
-    cancelOrder(orderId: bigint): Promise<void | TransactionResult<Transaction<unknown>>>;
-    cancelAllOrders(asset: Asset): Promise<void | TransactionResult<Transaction<unknown>>>;
+    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>>>;
+    setValue(value: number): 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>>>;
+    placeOrder(asset: Asset, price: Decimal, size: Decimal, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    placeTpsls(asset: Asset, tpslOrders: TpslOrder[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    replaceOrder(existingOrderId: bigint, asset: Asset, price: Decimal, size: Decimal, side: Side, orderType?: OrderType, reduceOnly?: boolean, tpslOrders?: TpslOrder[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    cancelTpsl(tpslOrderId: bigint): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    cancelOrder(orderId: bigint): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    cancelAllOrders(asset: Asset): Promise<TransactionResult<Transaction<RuntimeCall>>>;
     updatePricing(pricing_updates: {
         asset: Asset;
         medianCexPrice: Decimal;
         oraclePrice: Decimal;
         diffEma: Decimal;
-    }[], 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>>>;
+    }[], publishTimestamp?: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updateAssetMaxLeverage(asset: Asset, maxLeverage: number): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updatePremiumIndexes(assetIds: Asset[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    updateFunding(assetIds: Asset[]): 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>>>;
     liquidate(address: Address, positions?: {
         asset: Asset;
         size: Decimal;
-    }[]): Promise<void | TransactionResult<Transaction<unknown>>>;
-    liquidateSpotLiability(address: Address, liabilityAssetId: Asset, collateralAssetId: Asset, liabilityAmount: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
-    depositToUsdcPnlPool(amount: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
-    depositToInsuranceFund(amount: Decimal): Promise<void | TransactionResult<Transaction<unknown>>>;
+    }[]): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    liquidateSpotLiability(address: Address, liabilityAssetId: Asset, collateralAssetId: Asset, liabilityAmount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    depositToUsdcPnlPool(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
+    depositToInsuranceFund(amount: Decimal): Promise<TransactionResult<Transaction<RuntimeCall>>>;
 }

package/dist/types/connection.d.ts

@@ -1,11 +1,10 @@
-import { TokenId, Address } from "./types";
+import type { Address, TokenId } from "./types";
 export declare class BaseConnection {
     endpoint: string;
-    constructor(endpoint?: string);
+    constructor(rawEndpoint?: 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

@@ -1,4 +1,4 @@
-import { Network } from "./types";
+import type { Network } from "./types";
 export declare const TOKEN_ADDRESSES: {
     readonly GAS: "token_1nyl0e0yweragfsatygt24zmd8jrr2vqtvdfptzjhxkguz2xxx3vs0y07u7";
     readonly USDC: "token_1zh04r2k3kk0jf3xzr8cfpcm6qntumxwdvglq75g2ynwcu7daca0qm9ccg3";

package/dist/types/exchange.d.ts

@@ -1,7 +1,7 @@
 import { BaseConnection } from "./connection";
-import { Orderbook } from "./orderbook";
-import { AssetId, Network } from "./types";
-import { Order, OrderbookData, BorrowLendMarket, Pricing, PerpMarket, MarginConfig, UsdcPnlPool, UsdcInsuranceFund, UserAccount } from "./zod-types/rest";
+import type { Orderbook } from "./orderbook";
+import type { AssetId, Network } from "./types";
+import { type BorrowLendMarket, type MarginConfig, type Order, type OrderbookData, type PerpMarket, type Pricing, type UsdcInsuranceFund, type UsdcPnlPool, type UserAccount } from "./zod-types/rest";
 export declare class ExchangeConnection extends BaseConnection {
     private wsManager;
     constructor(network: Network);

package/dist/types/orderbook.d.ts

@@ -1,6 +1,6 @@
-import { Asset } from "./types";
-import { OrderbookData } from "./zod-types/rest";
-import { OrderbookUpdate } from "./zod-types/ws";
+import type { Asset } from "./types";
+import type { OrderbookData } from "./zod-types/rest";
+import type { OrderbookUpdate } from "./zod-types/ws";
 type Price = number;
 type TotalSize = number;
 type OrderbookLevel = [Price, TotalSize];

package/dist/types/rollupTypes.d.ts

@@ -0,0 +1,135 @@
+import type { Address, AssetId, TokenId } from "./types";
+type ExactlyOne<T, Keys extends keyof T = keyof T> = {
+    [K in Keys]: {
+        [P in K]: T[P];
+    } & {
+        [P in Exclude<Keys, K>]?: never;
+    };
+}[Keys];
+type BankCallMessage = {
+    transfer: {
+        to: Address;
+        coins: {
+            amount: string;
+            token_id: TokenId;
+        };
+    };
+    mint: {
+        mint_to_address: Address;
+        coins: {
+            amount: string;
+            token_id: TokenId;
+        };
+    };
+};
+type Tpsl = {
+    order_price: number;
+    trigger_price: number;
+    trigger_direction: string;
+    tpsl_price_condition: string;
+    size: number;
+    order_type: string;
+};
+type ExchangeCallMessage = {
+    set_value: number;
+    deposit: {
+        asset_id: AssetId;
+        amount: number;
+    };
+    withdraw: {
+        asset_id: AssetId;
+        amount: number;
+    };
+    borrow_spot: {
+        asset_id: AssetId;
+        amount: number;
+    };
+    place_order: {
+        order_args: {
+            asset_id: AssetId;
+            price: number;
+            size: number;
+            side: string;
+            order_type: string;
+            reduce_only: boolean;
+        };
+        tpsls: Tpsl[];
+    };
+    place_tpsls: {
+        asset_id: AssetId;
+        tpsls: Tpsl[];
+    };
+    replace_order: {
+        existing_order_id: string;
+        order_args: {
+            asset_id: AssetId;
+            price: number;
+            size: number;
+            side: string;
+            order_type: string;
+            reduce_only: boolean;
+        };
+        tpsls: Tpsl[];
+    };
+    cancel_tpsl: {
+        tpsl_order_id: string;
+    };
+    cancel_order: {
+        order_id: string;
+    };
+    cancel_all_orders: {
+        asset_id: AssetId;
+    };
+    update_pricing: {
+        prices_to_update: {
+            asset_id: AssetId;
+            median_cex_price: number;
+            oracle_price: number;
+            diff_ema: number;
+        }[];
+        publish_timestamp: number;
+    };
+    update_asset_max_leverage: {
+        asset_id: AssetId;
+        max_leverage: number;
+    };
+    update_premium_indexes: {
+        asset_ids: AssetId[];
+    };
+    update_funding: {
+        asset_ids: AssetId[];
+    };
+    apply_funding: {
+        addresses: Address[];
+    };
+    force_cancel_orders: {
+        user_address: Address;
+    };
+    force_close_positions: {
+        address: Address;
+    };
+    liquidate: {
+        address: Address;
+        positions: {
+            asset_id: AssetId;
+            size: number;
+        }[] | null;
+    };
+    liquidate_spot_liability: {
+        liquidatee_address: Address;
+        liability_asset_id: AssetId;
+        collateral_asset_id: AssetId;
+        liability_amount: number;
+    };
+    deposit_to_usdc_pnl_pool: {
+        usdc_amount: number;
+    };
+    deposit_to_insurance_fund: {
+        usdc_amount: number;
+    };
+};
+export type RuntimeCall = ExactlyOne<{
+    exchange: ExactlyOne<ExchangeCallMessage>;
+    bank: ExactlyOne<BankCallMessage>;
+}>;
+export {};

package/dist/types/types.d.ts

@@ -1,9 +1,5 @@
-import Decimal from "decimal.js";
-export type CallMessage = {
-    [module: string]: {
-        [instruction: string]: string | number | object;
-    };
-};
+export { MarginType, EquityType } from "./bullet-wasm";
+import type Decimal from "decimal.js";
 export type PrivateKey = string;
 export type PublicKey = string;
 export type Address = string;
@@ -42,15 +38,6 @@ export type TpslOrder = {
     size: Decimal;
     orderType: OrderType;
 };
-export declare enum EquityType {
-    Unweighted = 0,
-    WeightedInitial = 1,
-    WeightedMaintenance = 2
-}
-export declare enum MarginType {
-    Initial = 0,
-    Maintenance = 1
-}
 export declare class BulletError extends Error {
     originalError?: Error | undefined;
     code: string;

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

@@ -1,6 +1,6 @@
-import { PrivateKey, PublicKey } from "../types";
+import type { Signer } from "@sovereign-sdk/signers";
+import type { PrivateKey, PublicKey } from "../types";
 import { Wallet } from "./wallet";
-import { Signer } from "@sovereign-sdk/signers";
 export declare class NodeWallet extends Wallet {
     private privateKey;
     chainId: number;

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

@@ -1,5 +1,5 @@
-import { PublicKey, Address } from "../types";
-import { Signer } from "@sovereign-sdk/signers";
+import type { Signer } from "@sovereign-sdk/signers";
+import type { Address, PublicKey } from "../types";
 export declare abstract class Wallet {
     address: Address;
     publicKey: PublicKey;