@bulletxyz/bullet-sdk 0.49.6 → 0.49.8-rc.0

package/dist/browser/index.js

@@ -13,6 +13,15 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: !0,
+      configurable: !0,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
 
 // ../node_modules/bech32/dist/index.js
 var require_dist = __commonJS((exports) => {
@@ -319,6 +328,14 @@ var require_eventemitter3 = __commonJS((exports, module) => {
     module.exports = EventEmitter;
 });
 
+// src/bullet-wasm/loader.ts
+var exports_loader = {};
+__export(exports_loader, {
+  initialize: () => initialize,
+  MarginMode: () => MarginMode,
+  BulletWasm: () => BulletWasm
+});
+
 // src/bullet-wasm/wasm-glue.js
 class BulletWasm {
   __destroy_into_raw() {
@@ -1192,6 +1209,7 @@ async function initialize(wasmSource) {
     throw initPromise = null, err;
   }), initPromise;
 }
+
 // ../node_modules/@noble/hashes/esm/utils.js
 /*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 function isBytes(a) {
@@ -1700,6 +1718,7 @@ ${bids}`;
 import { z as z2 } from "zod";
 
 // src/zod-types/index.ts
+import bs582 from "bs58";
 import Decimal3 from "decimal.js";
 import { z } from "zod";
 var I16_MAX = 32767, I16_MIN = -32768, I64_MAX = 9223372036854775807n, I64_MIN = -9223372036854775808n, U8_MAX = 255, U16_MAX = 65535, U32_MAX = 4294967295, U64_MAX = 18446744073709551615n, U128_MAX = 340282366920938463463374607431768211455n, I64Schema = z.union([z.string(), z.number(), z.bigint()]).transform((val) => BigInt(val)).pipe(z.bigint().min(I64_MIN).max(I64_MAX)).describe("Signed 64-bit integer"), U8Schema = z.union([z.string(), z.number()]).transform((val) => Number(val)).pipe(z.number().int().min(0).max(U8_MAX)).describe("Unsigned 8-bit integer (0-255)"), U16Schema = z.union([z.string(), z.number()]).transform((val) => Number(val)).pipe(z.number().int().min(0).max(U16_MAX)).describe("Unsigned 16-bit integer (0-65535)"), I16Schema = z.union([z.string(), z.number()]).transform((val) => Number(val)).pipe(z.number().int().min(I16_MIN).max(I16_MAX)).describe("Signed 16-bit integer (-32768-32767)"), U32Schema = z.union([z.string(), z.number()]).transform((val) => Number(val)).pipe(z.number().int().min(0).max(U32_MAX)).describe("Unsigned 32-bit integer"), U64Schema = z.union([z.string(), z.number(), z.bigint()]).transform((val) => BigInt(val)).pipe(z.bigint().min(0n).max(U64_MAX)).describe("Unsigned 64-bit integer"), U128Schema = z.union([z.string(), z.number(), z.bigint()]).transform((val) => BigInt(val)).pipe(z.bigint().min(0n).max(U128_MAX)).describe("Unsigned 128-bit integer for large amounts"), DecimalSchema = z.union([z.string(), z.number()]).transform((val, ctx) => {
@@ -1713,7 +1732,7 @@ var I16_MAX = 32767, I16_MIN = -32768, I64_MAX = 9223372036854775807n, I64_MIN =
   }
 }).describe("High-precision decimal number using Decimal.js"), Base58Address = z.string().pipe(z.string().regex(/^[1-9A-HJ-NP-Za-km-z]{32,44}$/, {
   error: "Invalid Base58 address format"
-})).describe("Solana Base58-encoded public key address (32-44 characters)"), AssetId = U16Schema.describe("Unique identifier for a trading asset"), MarketId = U16Schema.describe("Unique identifier for a trading market"), OrderId = U64Schema.describe("Unique identifier for an order in the system"), TradeId = U64Schema.describe("Unique identifier for an executed trade"), ClientOrderId = U64Schema.describe("Client-provided order identifier for idempotency"), TriggerOrderId = U64Schema.describe("Unique identifier for a trigger/conditional order"), TwapId = U64Schema.describe("Unique identifier for a TWAP order"), Amount = U128Schema.describe("Token amount in smallest unit (e.g., lamports for SOL)"), UnixTimestampMicros = I64Schema.describe("Unix timestamp in microseconds since epoch"), createJsonMap = (keySchema, valueSchema, options) => {
+})).describe("Solana Base58-encoded public key address (32-44 characters)"), BytesAsBase58Address = z.array(U8Schema).transform((bytes) => bs582.encode(new Uint8Array(bytes))).describe("Raw byte array converted to Base58-encoded address string"), AssetId = U16Schema.describe("Unique identifier for a trading asset"), MarketId = U16Schema.describe("Unique identifier for a trading market"), OrderId = U64Schema.describe("Unique identifier for an order in the system"), TradeId = U64Schema.describe("Unique identifier for an executed trade"), ClientOrderId = U64Schema.describe("Client-provided order identifier for idempotency"), TriggerOrderId = U64Schema.describe("Unique identifier for a trigger/conditional order"), TwapId = U64Schema.describe("Unique identifier for a TWAP order"), Amount = U128Schema.describe("Token amount in smallest unit (e.g., lamports for SOL)"), UnixTimestampMicros = I64Schema.describe("Unix timestamp in microseconds since epoch"), createJsonMap = (keySchema, valueSchema, options) => {
   let schema = z.record(z.string(), valueSchema).transform((obj) => new Map(Object.entries(obj).map(([k, v]) => [keySchema.parse(k), v])));
   if (options?.description)
     schema.describe(options.description);
@@ -1940,10 +1959,11 @@ var MARKET_KINDS = ["perp", "spot"], SIDES = ["bid", "ask"], TRIGGER_DIRECTIONS
 ], createBaseResponse = (schema) => schema, VersionedV0 = (schema) => z3.object({ V0: schema }).transform((d) => ({
   version: "V0",
   data: d.V0
-})), VersionedV1 = (schema) => z3.object({ V1: schema }).transform((d) => ({
-  version: "V1",
-  data: d.V1
 }));
+var VersionedV2 = (schema) => z3.object({ V2: schema }).transform((d) => ({
+  version: "V2",
+  data: d.V2
+})), VersionedV1Value = (schema) => z3.object({ V1: schema }).transform((d) => d.V1), UnversionedOrV1 = (schema) => z3.union([schema, VersionedV1Value(schema)]);
 var StateResponseSchemas = {
   RollupSchema: (valueSchema) => createBaseResponse(z3.object({ schema: valueSchema })),
   StateValue: (valueSchema) => createBaseResponse(z3.object({ value: valueSchema.nullable() })),
@@ -2016,7 +2036,7 @@ var StateResponseSchemas = {
 }), PendingTpslPair = z3.object({
   tpsl_pair: TpslPair,
   dynamic_size: z3.boolean()
-}), PerpOrder = z3.object({
+}), PerpOrder = UnversionedOrV1(z3.object({
   side: z3.enum(SIDES),
   market_id: MarketId,
   order_id: OrderId,
@@ -2027,8 +2047,9 @@ var StateResponseSchemas = {
   filled_size: DecimalSchema,
   filled_cot: DecimalSchema,
   owner: Base58Address,
-  reserved_pending_tpsl_pair_ids: z3.string().nullable()
-}), SpotOrder = z3.object({
+  reserved_pending_tpsl_pair_ids: z3.string().nullable(),
+  expiry_timestamp: UnixTimestampMicros.nullable()
+})), SpotOrder = UnversionedOrV1(z3.object({
   side: z3.enum(SIDES),
   market_id: MarketId,
   order_id: OrderId,
@@ -2039,8 +2060,9 @@ var StateResponseSchemas = {
   remaining_base_lots: DecimalSchema,
   filled_base_lots: DecimalSchema,
   filled_cot: DecimalSchema,
-  owner: Base58Address
-}), Order = z3.union([PerpOrder, SpotOrder]), TriggerOrder = z3.object({
+  owner: Base58Address,
+  expiry_timestamp: UnixTimestampMicros.nullable()
+})), Order = z3.union([PerpOrder, SpotOrder]), TriggerOrder = z3.object({
   side: z3.enum(SIDES),
   market_id: MarketId,
   trigger_order_id: TriggerOrderId,
@@ -2053,7 +2075,18 @@ var StateResponseSchemas = {
   owner: Base58Address,
   last_update_timestamp: UnixTimestampMicros,
   linked_trigger_order_id: TriggerOrderId.nullable()
-}), RewardVariant = z3.enum(["referral", "liquidity"]), MarketTradingStatus = z3.enum(["active", "halted", "cleaning", "cleaned"]), FeeTier = z3.enum(["tier0", "tier1", "tier2", "tier3", "tier4"]), TradingMode = z3.enum(["iso", "cross"]), PerpLedger = z3.object({
+}), RewardVariant = z3.enum(["referral", "liquidity"]), MarketTradingStatus = z3.enum(["active", "halted", "cleaning", "cleaned"]), FeeTier = z3.enum([
+  "tier0",
+  "tier1",
+  "tier2",
+  "tier3",
+  "tier4",
+  "tier5",
+  "tier6",
+  "tier7",
+  "tier8",
+  "tier9"
+]), TradingMode = z3.enum(["iso", "cross"]), PerpLedger = UnversionedOrV1(z3.object({
   trading_mode: TradingMode,
   order_ids: z3.array(OrderId),
   trigger_order_ids: z3.array(TriggerOrderId),
@@ -2064,7 +2097,7 @@ var StateResponseSchemas = {
   twap_ids: z3.array(TwapId),
   twap_open_bid_lots: DecimalSchema,
   twap_open_ask_lots: DecimalSchema
-}), SpotLedger = z3.object({
+})), SpotLedger = z3.object({
   order_ids: z3.array(OrderId),
   trigger_order_ids: z3.array(TriggerOrderId),
   twap_ids: z3.array(TwapId)
@@ -2087,7 +2120,7 @@ var StateResponseSchemas = {
   cost_of_trade: DecimalSchema,
   reduce_only: z3.boolean(),
   owner: Base58Address
-}), OrdersLedger = z3.object({
+}), OrdersLedger = UnversionedOrV1(z3.object({
   client_order_ids: createJsonMap(ClientOrderId, OrderId),
   perp_orders: createJsonMap(OrderId, PerpOrder),
   perp_trigger_orders: createJsonMap(TriggerOrderId, TriggerOrder),
@@ -2095,7 +2128,7 @@ var StateResponseSchemas = {
   spot_orders: createJsonMap(OrderId, SpotOrder),
   spot_trigger_orders: createJsonMap(TriggerOrderId, TriggerOrder),
   twaps: createJsonMap(TwapId, Twap)
-}), TriggerNodesStore = z3.object({
+})), TriggerNodesStore = z3.object({
   inactive: createJsonMap(z3.string(), createJsonMap(z3.string(), z3.any())),
   active: z3.array(z3.any())
 }), ActiveTwap = z3.object({
@@ -2159,6 +2192,17 @@ var StateResponseSchemas = {
   perp_leverage_tables: createJsonMap(MarketId, LeverageTable),
   borrow_lend_risk_configs: createJsonMap(AssetId, BorrowLendRiskConfig)
 }), GlobalConfig = z3.object({
+  max_orders_per_user: U16Schema,
+  max_trigger_orders_per_user: U16Schema,
+  max_orders_per_batch_msg: U16Schema,
+  max_trigger_orders_to_execute_per_msg: U16Schema,
+  min_notional_twap_value: DecimalSchema,
+  min_notional_twap_value_per_order: DecimalSchema,
+  twap_execution_interval_seconds: U64Schema,
+  user_deposit_limits_per_asset: createJsonMap(AssetId, DecimalSchema),
+  whitelisted_users_for_deposit: createJsonSet(Base58Address),
+  pyth_lazer_trusted_signers: createJsonSet(BytesAsBase58Address)
+}), LegacyGlobalConfigV0 = z3.object({
   max_orders_per_user: U16Schema,
   max_trigger_orders_per_user: U16Schema,
   max_orders_per_batch_msg: U16Schema,
@@ -2176,6 +2220,14 @@ var StateResponseSchemas = {
   credits: Base58Address,
   referrals: Base58Address
 }), AssetInfo = z3.object({
+  id: AssetId,
+  name: z3.string(),
+  token_id: z3.string().nullable(),
+  decimals: U8Schema,
+  withdraw_fee: DecimalSchema,
+  pyth_lazer_feed_id: z3.number().nullable(),
+  pyth_lazer_quote_feed_id: z3.number().nullable()
+}), LegacyAssetInfoV0 = z3.object({
   id: AssetId,
   name: z3.string(),
   token_id: z3.string().nullable(),
@@ -2277,13 +2329,20 @@ var StateResponseSchemas = {
   flags: U32Schema
 }), Schemas = {
   DummyValue: z3.number(),
-  ExchangeInfoV1: z3.object({
+  ExchangeInfoV2: z3.object({
     global_config: GlobalConfig,
     admins: AdminRegistry,
     assets: createJsonMap(AssetId, AssetInfo),
     markets: createJsonMap(MarketId, MarketInfo),
     vaults: VaultRegistry
   }),
+  ExchangeInfoV1: z3.object({
+    global_config: LegacyGlobalConfigV0,
+    admins: AdminRegistry,
+    assets: createJsonMap(AssetId, LegacyAssetInfoV0),
+    markets: createJsonMap(MarketId, MarketInfo),
+    vaults: VaultRegistry
+  }),
   ExchangeAssetsV0: z3.object({
     cross_assets: CrossAssets,
     iso_assets: createJsonMap(MarketId, IsoAssets),
@@ -2295,7 +2354,7 @@ var StateResponseSchemas = {
     bids: z3.array(PriceLevelL2),
     asks: z3.array(PriceLevelL2)
   }),
-  UserAccount: z3.object({
+  UserAccount: UnversionedOrV1(z3.object({
     account_variant: z3.discriminatedUnion("type", [
       z3.object({
         type: z3.literal("master"),
@@ -2314,7 +2373,7 @@ var StateResponseSchemas = {
     perp_ledgers: createJsonMap(MarketId, PerpLedger),
     spot_ledgers: createJsonMap(MarketId, SpotLedger),
     orders_ledger: OrdersLedger
-  }),
+  })),
   UserAccountConfigV0: z3.object({
     delegates: createJsonMap(Base58Address, z3.string())
   }),
@@ -2368,7 +2427,7 @@ var StateResponseSchemas = {
 }, ResponseSchemas = {
   DummyValue: StateResponseSchemas.StateValue(Schemas.DummyValue),
   Order: StateResponseSchemas.StateMapElement(OrderId, Order),
-  ExchangeInfo: StateResponseSchemas.StateValue(VersionedV1(Schemas.ExchangeInfoV1)),
+  ExchangeInfo: StateResponseSchemas.StateValue(VersionedV2(Schemas.ExchangeInfoV2)),
   ExchangeAssets: StateResponseSchemas.StateValue(VersionedV0(Schemas.ExchangeAssetsV0)),
   RiskEngine: StateResponseSchemas.StateValue(VersionedV0(Schemas.RiskEngineV0)),
   ExecutionIds: StateResponseSchemas.StateValue(VersionedV0(Schemas.ExecutionIdsV0)),
@@ -2450,6 +2509,41 @@ var WasmResponseSchemas = {
 };
 
 // src/client.ts
+function serializeExchangeInfoForWasm(exchangeInfo) {
+  return serializeVersioned({
+    version: exchangeInfo.version,
+    data: {
+      ...exchangeInfo.data,
+      global_config: {
+        ...exchangeInfo.data.global_config,
+        pyth_lazer_trusted_signers: Array.from(exchangeInfo.data.global_config.pyth_lazer_trusted_signers, (signer) => Array.from(base58ToBytes(signer)))
+      }
+    }
+  });
+}
+function wrapVersion(version, data) {
+  return { [version]: data };
+}
+function mapValues(map, transform) {
+  return new Map(Array.from(map.entries(), ([key, value]) => [key, transform(value)]));
+}
+function serializeOrdersLedgerForWasm(ordersLedger) {
+  return wrapVersion("V1", {
+    ...ordersLedger,
+    perp_orders: mapValues(ordersLedger.perp_orders, (order) => wrapVersion("V1", order)),
+    spot_orders: mapValues(ordersLedger.spot_orders, (order) => wrapVersion("V1", order))
+  });
+}
+function serializeUserAccountForWasm(userAccount) {
+  return serializeVersioned({
+    version: "V1",
+    data: {
+      ...userAccount,
+      perp_ledgers: mapValues(userAccount.perp_ledgers, (ledger) => wrapVersion("V1", ledger)),
+      orders_ledger: serializeOrdersLedgerForWasm(userAccount.orders_ledger)
+    }
+  });
+}
 var DEFAULT_TRANSACTION_OPTS = {
   maxPriorityFeeBps: 0,
   maxFee: "10000000000",
@@ -2691,71 +2785,71 @@ class ReadOnlyClient {
     return position.cost_of_trades.div(position.size.abs());
   }
   calculatePerpUnrealizedPnl(marginMode, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_perp_unrealized_pnl(marginMode, userAccountObject, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_perp_unrealized_pnl(marginMode, userAccountObject, riskEngineObject);
     return new Decimal4(result);
   }
   calculateAccountEquity(marginMode, equityType, conservative, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_account_equity(marginMode, userAccountObject, conservative, equityType, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_account_equity(marginMode, userAccountObject, conservative, equityType, riskEngineObject);
     return new Decimal4(result);
   }
   calculateAccountLeverage(marginMode, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_account_leverage(marginMode, userAccountObject, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_account_leverage(marginMode, userAccountObject, riskEngineObject);
     return new Decimal4(result);
   }
   calculateAvailableMargin(marginMode, marginType, conservative, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_available_margin(marginMode, userAccountObject, conservative, marginType, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_available_margin(marginMode, userAccountObject, conservative, marginType, riskEngineObject);
     return new Decimal4(result);
   }
   calculateUsedMargin(marginMode, withdrawal, marginType, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_margin(marginMode, userAccountObject, withdrawal, marginType, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_margin(marginMode, userAccountObject, withdrawal, marginType, riskEngineObject);
     return new Decimal4(result);
   }
   calculateUsedPerpMargin(marginMode, userAccount, marginType, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_perp_margin(marginMode, userAccountObject, marginType, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_perp_margin(marginMode, userAccountObject, marginType, riskEngineObject);
     return new Decimal4(result);
   }
   calculateUsedBorrowLendMargin(userAccount, marginType, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_borrow_lend_margin(userAccountObject, marginType, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_used_borrow_lend_margin(userAccountObject, marginType, riskEngineObject);
     return new Decimal4(result);
   }
   calculateEstimatedLiquidationPrice(marginMode, market, userAccount, riskEngine) {
-    let marketId = this.getMarketId(market), baseAssetId = this.getMarketMeta(market).baseAssetId, userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_estimated_liquidation_price(marginMode, userAccountObject, marketId, baseAssetId, riskEngineObject);
+    let marketId = this.getMarketId(market), baseAssetId = this.getMarketMeta(market).baseAssetId, userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_estimated_liquidation_price(marginMode, userAccountObject, marketId, baseAssetId, riskEngineObject);
     return new Decimal4(result);
   }
   calculateLiquidationRiskPercentage(marginMode, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_liquidation_risk_percentage(marginMode, userAccountObject, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_liquidation_risk_percentage(marginMode, userAccountObject, riskEngineObject);
     return new Decimal4(result);
   }
   calculateMarginBalance(marginMode, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_margin_balance(marginMode, userAccountObject, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_margin_balance(marginMode, userAccountObject, riskEngineObject);
     return WasmResponseSchemas.MarginBalanceSummarySchema.parse(result);
   }
   calculatePerpMarginRequirement(marginMode, userAccount, marginType, withdrawal, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_perp_margin_requirement(marginMode, userAccountObject, marginType, withdrawal, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_perp_margin_requirement(marginMode, userAccountObject, marginType, withdrawal, riskEngineObject);
     return new Decimal4(result);
   }
   calculateForceCancelRiskPercentage(marginMode, userAccount, riskEngine) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_force_cancel_risk_percentage(marginMode, userAccountObject, riskEngineObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_force_cancel_risk_percentage(marginMode, userAccountObject, riskEngineObject);
     return new Decimal4(result);
   }
   calculateMaxBorrowAmount(asset, userAccount, riskEngine) {
-    let assetId = this.getAssetId(asset), userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_max_borrow_amount(assetId, userAccountObject, riskEngineObject);
+    let assetId = this.getAssetId(asset), userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_max_borrow_amount(assetId, userAccountObject, riskEngineObject);
     return new Decimal4(result);
   }
   calculateMaxOrderSize(marginMode, market, price, side, orderType, reduceOnly, userAccount, riskEngine, orderbook, nIterations = 100, errorTolerance = new Decimal4(0.0001)) {
-    let marketId = this.getMarketId(market), userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.calculate_max_order_size(marginMode, marketId, price.toFixed(), side, orderType, reduceOnly, userAccountObject, riskEngineObject, orderbookObject, nIterations, errorTolerance.toFixed());
+    let marketId = this.getMarketId(market), userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.calculate_max_order_size(marginMode, marketId, price.toFixed(), side, orderType, reduceOnly, userAccountObject, riskEngineObject, orderbookObject, nIterations, errorTolerance.toFixed());
     return new Decimal4(result);
   }
   calculateWithdrawableAmountOfCrossMarginAsset(asset, forTransferSpotCollateral, userAccount, riskEngine, exchangeInfo) {
-    let assetId = this.getAssetId(asset), userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), exchangeInfoObject = serializeVersioned(exchangeInfo), result = BulletWasm.calculate_withdrawable_amount_of_cross_margin_asset(assetId, forTransferSpotCollateral, userAccountObject, riskEngineObject, exchangeInfoObject);
+    let assetId = this.getAssetId(asset), userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), exchangeInfoObject = serializeExchangeInfoForWasm(exchangeInfo), result = BulletWasm.calculate_withdrawable_amount_of_cross_margin_asset(assetId, forTransferSpotCollateral, userAccountObject, riskEngineObject, exchangeInfoObject);
     return new Decimal4(result);
   }
   simulateUsedCrossMarginOnBorrow(asset, borrowAmount, userAccount, marginType, riskEngine) {
-    let assetId = this.getAssetId(asset), userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.simulate_used_cross_margin_on_borrow(assetId, borrowAmount.toFixed(), userAccountObject, marginType, riskEngineObject);
+    let assetId = this.getAssetId(asset), userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.simulate_used_cross_margin_on_borrow(assetId, borrowAmount.toFixed(), userAccountObject, marginType, riskEngineObject);
     return WasmResponseSchemas.SimulationResultSchema.parse(result);
   }
   simulateUsedCrossMarginOnOrder(market, newOrderArgs, userAccount, riskEngine, orderbook) {
-    let marketId = this.getMarketId(market), userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.simulate_used_cross_margin_on_order(marketId, {
+    let marketId = this.getMarketId(market), userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.simulate_used_cross_margin_on_order(marketId, {
       price: newOrderArgs.price.toFixed(),
       size: newOrderArgs.size.toFixed(),
       side: newOrderArgs.side,
@@ -2765,7 +2859,7 @@ class ReadOnlyClient {
     return WasmResponseSchemas.SimulationResultSchema.parse(result);
   }
   simulateCrossMarginEstimatedLiquidationPriceOnOrder(market, newOrderArgs, userAccount, riskEngine, orderbook) {
-    let marketId = this.getMarketId(market), baseAssetId = this.getMarketMeta(market).baseAssetId, userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.simulate_cross_margin_estimated_liquidation_price_on_order(marketId, {
+    let marketId = this.getMarketId(market), baseAssetId = this.getMarketMeta(market).baseAssetId, userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), orderbookObject = serialize(orderbook), result = BulletWasm.simulate_cross_margin_estimated_liquidation_price_on_order(marketId, {
       price: newOrderArgs.price.toFixed(),
       size: newOrderArgs.size.toFixed(),
       side: newOrderArgs.side,
@@ -2775,7 +2869,7 @@ class ReadOnlyClient {
     return WasmResponseSchemas.SimulationResultSchema.parse(result);
   }
   calculatePositionsAdditionalMetadata(userAccount, riskEngine, exchangeInfo) {
-    let userAccountObject = serialize(userAccount), riskEngineObject = serializeVersioned(riskEngine), exchangeInfoObject = serializeVersioned(exchangeInfo), result = BulletWasm.calculate_positions_additional_metadata(userAccountObject, riskEngineObject, exchangeInfoObject);
+    let userAccountObject = serializeUserAccountForWasm(userAccount), riskEngineObject = serializeVersioned(riskEngine), exchangeInfoObject = serializeExchangeInfoForWasm(exchangeInfo), result = BulletWasm.calculate_positions_additional_metadata(userAccountObject, riskEngineObject, exchangeInfoObject);
     return WasmResponseSchemas.PositionAdditionalMetadataSchema.parse(result);
   }
   calculateBorrowLendPoolAdditionalMetadata(borrowLendPools, asset) {
@@ -2783,7 +2877,7 @@ class ReadOnlyClient {
     return WasmResponseSchemas.BorrowLendMarketAdditionalMetadataSchema.parse(result);
   }
   calculateCrossMarginAccountSummaryBatch(userAccounts, riskEngine, useWeightedEquity = !0) {
-    let userAccountsObject = serialize(userAccounts), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_cross_margin_account_summary_batch(userAccountsObject, riskEngineObject, useWeightedEquity);
+    let userAccountsObject = userAccounts.map(serializeUserAccountForWasm), riskEngineObject = serializeVersioned(riskEngine), result = BulletWasm.calculate_cross_margin_account_summary_batch(userAccountsObject, riskEngineObject, useWeightedEquity);
     return WasmResponseSchemas.AccountSummaryBatchSchema.parse(result);
   }
   estimateHourlyFundingRate(market, riskEngine) {
@@ -3509,32 +3603,36 @@ class AuthenticatedClient extends ReadOnlyClient {
       }
     });
   }
-  async initAssetInfo(assetId, assetName, tokenId, decimals, withdrawFee) {
+  async initAssetInfo(assetId, assetName, tokenId, decimals, withdrawFee, pythLazerFeedId, pythLazerQuoteFeedId) {
     return await this.submitTransaction({
       exchange: {
         admin: {
-          init_asset_info: {
+          init_asset_info_v_1: {
             args: {
               asset_id: assetId,
               asset_name: assetName,
               token_id: tokenId,
               decimals,
-              withdraw_fee: this.encodeDecimal(withdrawFee)
+              withdraw_fee: this.encodeDecimal(withdrawFee),
+              pyth_lazer_feed_id: pythLazerFeedId ?? null,
+              pyth_lazer_quote_feed_id: pythLazerQuoteFeedId ?? null
             }
           }
         }
       }
     });
   }
-  async updateAssetInfo(asset, withdrawFee) {
+  async updateAssetInfo(asset, withdrawFee, pythLazerFeedId, pythLazerQuoteFeedId) {
     let assetId = this.getAssetId(asset);
     return await this.submitTransaction({
       exchange: {
         admin: {
-          update_asset_info: {
+          update_asset_info_v_1: {
             args: {
               asset_id: assetId,
-              withdraw_fee: this.encodeDecimal(withdrawFee)
+              withdraw_fee: this.encodeDecimal(withdrawFee),
+              pyth_lazer_feed_id: pythLazerFeedId ? pythLazerFeedId : null,
+              pyth_lazer_quote_feed_id: pythLazerQuoteFeedId ? pythLazerQuoteFeedId : null
             }
           }
         }
@@ -3545,7 +3643,7 @@ class AuthenticatedClient extends ReadOnlyClient {
     return await this.submitTransaction({
       exchange: {
         admin: {
-          update_global_config: {
+          update_global_config_v_1: {
             args: {
               max_orders_per_user: options.maxOrdersPerUser ?? null,
               max_trigger_orders_per_user: options.maxTriggerOrdersPerUser ?? null,
@@ -3558,7 +3656,8 @@ class AuthenticatedClient extends ReadOnlyClient {
                 assetId,
                 this.encodeDecimal(amount)
               ]) ?? null,
-              whitelisted_users_for_deposit: options.whitelistedUsersForDeposit ?? null
+              whitelisted_users_for_deposit: options.whitelistedUsersForDeposit ?? null,
+              pyth_lazer_trusted_signers: options.pyth_lazer_trusted_signers ?? null
             }
           }
         }
@@ -4368,6 +4467,9 @@ class LedgerWallet extends Wallet {
     await this.ledgerSigner.disconnect();
   }
 }
+
+// src/browser.ts
+var { BulletWasm: BulletWasm2, initialize: initialize2, MarginMode: MarginMode2 } = exports_loader;
 export {
   validateEndpoints,
   toNativeUnits,
@@ -4382,7 +4484,7 @@ export {
   isErrorType,
   isBulletError,
   isAbortError,
-  initialize,
+  initialize2 as initialize,
   hexToBytes,
   hexToBase64,
   hexToBase58,
@@ -4400,15 +4502,15 @@ export {
   ReadOnlyClient,
   Orderbook,
   NETWORKS,
-  MarginMode,
+  MarginMode2 as MarginMode,
   LedgerWallet,
   GLOBAL_DEFAULT_MAX_LEVERAGE,
   Client,
-  BulletWasm,
+  BulletWasm2 as BulletWasm,
   BulletError,
   BaseResponseSchemas,
   AuthenticatedClient,
   AbortError
 };
 
-//# debugId=866FE84FB953549964756E2164756E21
+//# debugId=3EFAFB027DC38DA364756E2164756E21