@ostium/builder-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,5013 @@
+'use strict';
+
+var viem = require('viem');
+var accounts = require('viem/accounts');
+var chains = require('viem/chains');
+var accountAbstraction = require('viem/account-abstraction');
+var permissionless = require('permissionless');
+var pimlico = require('permissionless/clients/pimlico');
+var accounts$1 = require('permissionless/accounts');
+var graphqlRequest = require('graphql-request');
+var formulae = require('@ostium/formulae');
+var WS = require('ws');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var WS__default = /*#__PURE__*/_interopDefault(WS);
+
+// src/client.ts
+
+// src/internal/erc20.ts
+var ERC20_ABI = [
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "account", type: "address" }
+    ],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/internal/decimal.ts
+function parseUsdc(amount) {
+  const amountStr = typeof amount === "number" ? amount.toString() : amount;
+  if (!amountStr || amountStr === "0") return 0n;
+  if (!/^\d+(\.\d+)?$/.test(amountStr)) {
+    throw new Error(`Invalid USDC amount: ${amountStr}`);
+  }
+  const [intPart, decPart = ""] = amountStr.split(".");
+  const paddedDec = decPart.padEnd(6, "0").slice(0, 6);
+  return BigInt(intPart + paddedDec);
+}
+function parsePrice(price) {
+  const priceStr = typeof price === "number" ? price.toString() : price;
+  if (!priceStr || priceStr === "0") return 0n;
+  if (!/^-?\d+(\.\d+)?$/.test(priceStr)) {
+    throw new Error(`Invalid price: ${priceStr}`);
+  }
+  const isNegative = priceStr.startsWith("-");
+  const absStr = isNegative ? priceStr.slice(1) : priceStr;
+  const [intPart, decPart = ""] = absStr.split(".");
+  const paddedDec = decPart.padEnd(18, "0").slice(0, 18);
+  const result = BigInt(intPart + paddedDec);
+  return isNegative ? -result : result;
+}
+function parseLeverage(leverage) {
+  if (leverage <= 0 || !Number.isFinite(leverage)) {
+    throw new Error(`Invalid leverage: ${leverage}`);
+  }
+  return BigInt(Math.round(leverage * 100));
+}
+
+// src/internal/precision.ts
+var PRECISION_6 = 1000000n;
+var PRECISION_18 = 1000000000000000000n;
+var DEFAULT_SLIPPAGE_PERCENTAGE = 0.25;
+var MIN_COLLATERAL_USD = 5;
+var MAX_COLLATERAL_USD = 2e6;
+var ORDER_TYPE_MAP = {
+  "market": 0,
+  // OpenOrderType.MARKET
+  "limit": 1,
+  // OpenOrderType.LIMIT
+  "stop": 2
+  // OpenOrderType.STOP
+};
+
+// src/internal/validation.ts
+var DECIMAL_RE = /^-?\d+(\.\d+)?$/;
+function assertDecimal(value, label) {
+  if (!DECIMAL_RE.test(value)) {
+    throw new Error(`Invalid ${label}: "${value}" is not a valid decimal number`);
+  }
+  if (parseFloat(value) <= 0) {
+    throw new Error(`Invalid ${label}: must be greater than zero, got "${value}"`);
+  }
+}
+function assertNonNegativeDecimal(value, label) {
+  if (!DECIMAL_RE.test(value)) {
+    throw new Error(`Invalid ${label}: "${value}" is not a valid decimal number`);
+  }
+  if (parseFloat(value) < 0) {
+    throw new Error(`Invalid ${label}: must be non-negative, got "${value}"`);
+  }
+}
+function extractOpenType(open) {
+  return ORDER_TYPE_MAP[open.t];
+}
+function validateTpSlDirection(open, tp, sl, openPrice) {
+  if (open.b) {
+    if (tp > 0n && tp <= openPrice) {
+      throw new Error(`Take profit (${open.tp}) must be above open price (${open.p}) for long positions`);
+    }
+    if (sl > 0n && sl >= openPrice) {
+      throw new Error(`Stop loss (${open.sl}) must be below open price (${open.p}) for long positions`);
+    }
+  } else {
+    if (tp > 0n && tp >= openPrice) {
+      throw new Error(`Take profit (${open.tp}) must be below open price (${open.p}) for short positions`);
+    }
+    if (sl > 0n && sl <= openPrice) {
+      throw new Error(`Stop loss (${open.sl}) must be above open price (${open.p}) for short positions`);
+    }
+  }
+}
+function validateCloseParams(close) {
+  if (close.r < 1 || close.r > 100) {
+    throw new Error(`Close percentage must be 1\u2013100, got ${close.r}`);
+  }
+  assertDecimal(close.p, "close price");
+}
+function validateModifyParams(input) {
+  if (input.a < 0) {
+    throw new Error(`Invalid pair index: ${input.a}`);
+  }
+  if (input.i < 0) {
+    throw new Error(`Invalid trade/order index: ${input.i}`);
+  }
+  if (!input.p && !input.tp && !input.sl) {
+    throw new Error("At least one of price, takeProfit, or stopLoss must be provided");
+  }
+  if (input.p) {
+    assertDecimal(input.p, "price");
+  }
+  if (input.tp) {
+    assertNonNegativeDecimal(input.tp, "take profit");
+  }
+  if (input.sl) {
+    assertNonNegativeDecimal(input.sl, "stop loss");
+  }
+}
+
+// src/internal/open-builder.ts
+var DEFAULT_CONFIG = {
+  defaultLeverage: 1,
+  maxLeverage: 100,
+  minOpenSize: MIN_COLLATERAL_USD
+};
+function buildTrade(open, traderAddress, config = {}) {
+  const mergedConfig = { ...DEFAULT_CONFIG, ...config };
+  const collateralUsd = parseFloat(open.s);
+  if (collateralUsd < mergedConfig.minOpenSize) {
+    throw new Error(`Collateral ${open.s} below minimum ${mergedConfig.minOpenSize}`);
+  }
+  const leverageNum = parseFloat(open.l);
+  if (leverageNum > mergedConfig.maxLeverage) {
+    throw new Error(`Leverage ${open.l} exceeds maximum ${mergedConfig.maxLeverage}`);
+  }
+  const collateral = parseUsdc(open.s);
+  const openPrice = parsePrice(open.p);
+  const leverage = parseLeverage(leverageNum);
+  const tp = open.tp ? parsePrice(open.tp) : 0n;
+  const sl = open.sl ? parsePrice(open.sl) : 0n;
+  if (tp > 0n || sl > 0n) {
+    validateTpSlDirection(open, tp, sl, openPrice);
+  }
+  const trade = {
+    collateral,
+    openPrice,
+    tp,
+    sl,
+    trader: traderAddress,
+    leverage,
+    pairIndex: BigInt(open.a),
+    index: 0n,
+    buy: open.b,
+    isDayTrade: open.d ?? false
+  };
+  return { trade, orderType: extractOpenType(open) };
+}
+function buildBuilderFee(builder) {
+  if (!builder) {
+    return {
+      builder: "0x0000000000000000000000000000000000000000",
+      builderFee: 0n
+    };
+  }
+  return {
+    builder: builder.b,
+    builderFee: BigInt(builder.f)
+  };
+}
+
+// src/internal/contracts.ts
+var ARBITRUM_MAINNET = {
+  chainId: 42161,
+  contracts: {
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    trading: "0x6D0bA1f9996DBD8885827e1b2e8f6593e7702411",
+    tradingStorage: "0xcCd5891083A8acD2074690F65d3024E7D13d66E7"
+  }
+};
+var ARBITRUM_TESTNET = {
+  chainId: 421614,
+  contracts: {
+    usdc: "0xe73B11Fb1e3eeEe8AF2a23079A4410Fe1B370548",
+    trading: "0x2A9B9c988393f46a2537B0ff11E98c2C15a95afe",
+    tradingStorage: "0x0b9F5243B29938668c9Cfbd7557A389EC7Ef88b8"
+  }
+};
+function getNetworkConfig(isTestnet = false) {
+  return isTestnet ? ARBITRUM_TESTNET : ARBITRUM_MAINNET;
+}
+
+// src/types.ts
+var OrderType = /* @__PURE__ */ ((OrderType2) => {
+  OrderType2["Market"] = "market";
+  OrderType2["Limit"] = "limit";
+  OrderType2["Stop"] = "stop";
+  return OrderType2;
+})(OrderType || {});
+var CancelOrderType = /* @__PURE__ */ ((CancelOrderType2) => {
+  CancelOrderType2["Limit"] = "limit";
+  CancelOrderType2["PendingOpen"] = "pendingOpen";
+  CancelOrderType2["PendingClose"] = "pendingClose";
+  return CancelOrderType2;
+})(CancelOrderType || {});
+
+// src/config.ts
+var DEFAULT_PIMLICO_URL = "https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161";
+var DEFAULT_PIMLICO_URL_TESTNET = "https://builder.ostium.io/v1/pimlico/sponsor?chainId=421614";
+function isGasless(config) {
+  return !!config.pimlicoUrl;
+}
+function isDelegated(config) {
+  return !!config.traderAddress;
+}
+
+// src/errors.ts
+var OstiumErrorCode = /* @__PURE__ */ ((OstiumErrorCode2) => {
+  OstiumErrorCode2["INVALID_CONFIG"] = "INVALID_CONFIG";
+  OstiumErrorCode2["VALIDATION_FAILED"] = "VALIDATION_FAILED";
+  OstiumErrorCode2["ALLOWANCE_INSUFFICIENT"] = "ALLOWANCE_INSUFFICIENT";
+  OstiumErrorCode2["SUBMISSION_FAILED"] = "SUBMISSION_FAILED";
+  OstiumErrorCode2["DELEGATION_FAILED"] = "DELEGATION_FAILED";
+  OstiumErrorCode2["CONTRACT_ERROR"] = "CONTRACT_ERROR";
+  OstiumErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
+  return OstiumErrorCode2;
+})(OstiumErrorCode || {});
+var OstiumError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "OstiumError";
+  }
+  code;
+  cause;
+};
+
+// src/signer/self.ts
+var SelfSignerStrategy = class {
+  traderAddress;
+  constructor(traderAddress) {
+    this.traderAddress = traderAddress;
+  }
+  prepare(encoded) {
+    return encoded;
+  }
+};
+
+// src/internal/contract.ts
+var TRADING_ABI = [
+  {
+    "inputs": [],
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "inputs": [],
+    "name": "AboveMaxAllowedCollateral",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "AlreadyMarketClosed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BelowFees",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "BelowMinLevPos",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "DelegateForbidden",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "DelegateReentrant",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "DelegatedActionFailed",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "ExposureLimits",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidCallData",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidInitialization",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidNonce",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "InvalidSignature",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "a",
+        "type": "address"
+      }
+    ],
+    "name": "IsContract",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "IsDone",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "IsPaused",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      }
+    ],
+    "name": "MaxPendingMarketOrdersReached",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      }
+    ],
+    "name": "MaxTradesPerPairReached",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "a",
+        "type": "address"
+      }
+    ],
+    "name": "NoDelegate",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "NoLimitFound",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "NoTradeFound",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      }
+    ],
+    "name": "NoTradeToTimeoutFound",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      }
+    ],
+    "name": "NotCloseMarketTimeoutOrder",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "caller",
+        "type": "address"
+      }
+    ],
+    "name": "NotDelegate",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "a",
+        "type": "address"
+      }
+    ],
+    "name": "NotGov",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NotInitializing",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "a",
+        "type": "address"
+      }
+    ],
+    "name": "NotManager",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      }
+    ],
+    "name": "NotOpenMarketTimeoutOrder",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "a",
+        "type": "address"
+      }
+    ],
+    "name": "NotTradesUpKeep",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      }
+    ],
+    "name": "NotYourOrder",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "NullAddr",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "index",
+        "type": "uint16"
+      }
+    ],
+    "name": "PairNotListed",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint8",
+        "name": "bits",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "SafeCastOverflowedUintDowncast",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "SignatureExpired",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "sender",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "TriggerPending",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      }
+    ],
+    "name": "WaitTimeout",
+    "type": "error"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint32",
+        "name": "leverage",
+        "type": "uint32"
+      }
+    ],
+    "name": "WrongLeverage",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "WrongParams",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "WrongSL",
+    "type": "error"
+  },
+  {
+    "inputs": [],
+    "name": "WrongTP",
+    "type": "error"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "enum IOstiumTradingStorage.LimitOrder",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "name": "AutomationCloseOrderInitiated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "AutomationOpenOrderInitiated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "delegator",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "delegate",
+        "type": "address"
+      }
+    ],
+    "name": "DelegateAdded",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "delegator",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "delegate",
+        "type": "address"
+      }
+    ],
+    "name": "DelegateRemoved",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bool",
+        "name": "done",
+        "type": "bool"
+      }
+    ],
+    "name": "Done",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint64",
+        "name": "version",
+        "type": "uint64"
+      }
+    ],
+    "name": "Initialized",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      }
+    ],
+    "name": "MarketCloseFailed",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      }
+    ],
+    "name": "MarketCloseOrderInitiated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "closePercentage",
+        "type": "uint16"
+      }
+    ],
+    "name": "MarketCloseOrderInitiatedV2",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "block",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "wantedPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint32",
+            "name": "slippageP",
+            "type": "uint32"
+          },
+          {
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "collateral",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint192",
+                "name": "openPrice",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "tp",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "sl",
+                "type": "uint192"
+              },
+              {
+                "internalType": "address",
+                "name": "trader",
+                "type": "address"
+              },
+              {
+                "internalType": "uint32",
+                "name": "leverage",
+                "type": "uint32"
+              },
+              {
+                "internalType": "uint16",
+                "name": "pairIndex",
+                "type": "uint16"
+              },
+              {
+                "internalType": "uint8",
+                "name": "index",
+                "type": "uint8"
+              },
+              {
+                "internalType": "bool",
+                "name": "buy",
+                "type": "bool"
+              },
+              {
+                "internalType": "bool",
+                "name": "isDayTrade",
+                "type": "bool"
+              }
+            ],
+            "internalType": "struct IOstiumTradingStorage.Trade",
+            "name": "trade",
+            "type": "tuple"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.PendingMarketOrder",
+        "name": "order",
+        "type": "tuple"
+      }
+    ],
+    "name": "MarketCloseTimeoutExecuted",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "block",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "wantedPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint32",
+            "name": "slippageP",
+            "type": "uint32"
+          },
+          {
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "collateral",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint192",
+                "name": "openPrice",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "tp",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "sl",
+                "type": "uint192"
+              },
+              {
+                "internalType": "address",
+                "name": "trader",
+                "type": "address"
+              },
+              {
+                "internalType": "uint32",
+                "name": "leverage",
+                "type": "uint32"
+              },
+              {
+                "internalType": "uint16",
+                "name": "pairIndex",
+                "type": "uint16"
+              },
+              {
+                "internalType": "uint8",
+                "name": "index",
+                "type": "uint8"
+              },
+              {
+                "internalType": "bool",
+                "name": "buy",
+                "type": "bool"
+              },
+              {
+                "internalType": "bool",
+                "name": "isDayTrade",
+                "type": "bool"
+              }
+            ],
+            "internalType": "struct IOstiumTradingStorage.Trade",
+            "name": "trade",
+            "type": "tuple"
+          },
+          {
+            "internalType": "uint16",
+            "name": "percentage",
+            "type": "uint16"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.PendingMarketOrderV2",
+        "name": "order",
+        "type": "tuple"
+      }
+    ],
+    "name": "MarketCloseTimeoutExecutedV2",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      }
+    ],
+    "name": "MarketOpenOrderInitiated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "block",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "wantedPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint32",
+            "name": "slippageP",
+            "type": "uint32"
+          },
+          {
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "collateral",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint192",
+                "name": "openPrice",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "tp",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "sl",
+                "type": "uint192"
+              },
+              {
+                "internalType": "address",
+                "name": "trader",
+                "type": "address"
+              },
+              {
+                "internalType": "uint32",
+                "name": "leverage",
+                "type": "uint32"
+              },
+              {
+                "internalType": "uint16",
+                "name": "pairIndex",
+                "type": "uint16"
+              },
+              {
+                "internalType": "uint8",
+                "name": "index",
+                "type": "uint8"
+              },
+              {
+                "internalType": "bool",
+                "name": "buy",
+                "type": "bool"
+              },
+              {
+                "internalType": "bool",
+                "name": "isDayTrade",
+                "type": "bool"
+              }
+            ],
+            "internalType": "struct IOstiumTradingStorage.Trade",
+            "name": "trade",
+            "type": "tuple"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.PendingMarketOrder",
+        "name": "order",
+        "type": "tuple"
+      }
+    ],
+    "name": "MarketOpenTimeoutExecuted",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "block",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "wantedPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint32",
+            "name": "slippageP",
+            "type": "uint32"
+          },
+          {
+            "components": [
+              {
+                "internalType": "uint256",
+                "name": "collateral",
+                "type": "uint256"
+              },
+              {
+                "internalType": "uint192",
+                "name": "openPrice",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "tp",
+                "type": "uint192"
+              },
+              {
+                "internalType": "uint192",
+                "name": "sl",
+                "type": "uint192"
+              },
+              {
+                "internalType": "address",
+                "name": "trader",
+                "type": "address"
+              },
+              {
+                "internalType": "uint32",
+                "name": "leverage",
+                "type": "uint32"
+              },
+              {
+                "internalType": "uint16",
+                "name": "pairIndex",
+                "type": "uint16"
+              },
+              {
+                "internalType": "uint8",
+                "name": "index",
+                "type": "uint8"
+              },
+              {
+                "internalType": "bool",
+                "name": "buy",
+                "type": "bool"
+              },
+              {
+                "internalType": "bool",
+                "name": "isDayTrade",
+                "type": "bool"
+              }
+            ],
+            "internalType": "struct IOstiumTradingStorage.Trade",
+            "name": "trade",
+            "type": "tuple"
+          },
+          {
+            "internalType": "uint16",
+            "name": "percentage",
+            "type": "uint16"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.PendingMarketOrderV2",
+        "name": "order",
+        "type": "tuple"
+      }
+    ],
+    "name": "MarketOpenTimeoutExecutedV2",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "value",
+        "type": "uint16"
+      }
+    ],
+    "name": "MarketOrdersTimeoutUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "MaxAllowedCollateralUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "OpenLimitCanceled",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "OpenLimitPlaced",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "collateral",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "openPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint192",
+            "name": "tp",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint192",
+            "name": "sl",
+            "type": "uint192"
+          },
+          {
+            "internalType": "address",
+            "name": "trader",
+            "type": "address"
+          },
+          {
+            "internalType": "uint32",
+            "name": "leverage",
+            "type": "uint32"
+          },
+          {
+            "internalType": "uint16",
+            "name": "pairIndex",
+            "type": "uint16"
+          },
+          {
+            "internalType": "uint8",
+            "name": "index",
+            "type": "uint8"
+          },
+          {
+            "internalType": "bool",
+            "name": "buy",
+            "type": "bool"
+          },
+          {
+            "internalType": "bool",
+            "name": "isDayTrade",
+            "type": "bool"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.Trade",
+        "name": "trade",
+        "type": "tuple"
+      },
+      {
+        "indexed": false,
+        "internalType": "enum IOstiumTradingStorage.OpenOrderType",
+        "name": "orderType",
+        "type": "uint8"
+      },
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "builder",
+            "type": "address"
+          },
+          {
+            "internalType": "uint32",
+            "name": "builderFee",
+            "type": "uint32"
+          }
+        ],
+        "indexed": false,
+        "internalType": "struct IOstiumTradingStorage.BuilderFee",
+        "name": "builderFee",
+        "type": "tuple"
+      }
+    ],
+    "name": "OpenLimitPlacedV2",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint192",
+        "name": "newPrice",
+        "type": "uint192"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint192",
+        "name": "newTp",
+        "type": "uint192"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint192",
+        "name": "newSl",
+        "type": "uint192"
+      }
+    ],
+    "name": "OpenLimitUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleFeeCharged",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleFeeChargedLimitCancelled",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "amount",
+        "type": "uint256"
+      }
+    ],
+    "name": "OracleFeeRefunded",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "bool",
+        "name": "paused",
+        "type": "bool"
+      }
+    ],
+    "name": "Paused",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "removeAmount",
+        "type": "uint256"
+      }
+    ],
+    "name": "RemoveCollateralInitiated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "orderId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "removeAmount",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "string",
+        "name": "reason",
+        "type": "string"
+      }
+    ],
+    "name": "RemoveCollateralRejected",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint192",
+        "name": "newSl",
+        "type": "uint192"
+      }
+    ],
+    "name": "SlUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint256",
+        "name": "topUpAmount",
+        "type": "uint256"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint32",
+        "name": "newLeverage",
+        "type": "uint32"
+      }
+    ],
+    "name": "TopUpCollateralExecuted",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": true,
+        "internalType": "uint256",
+        "name": "tradeId",
+        "type": "uint256"
+      },
+      {
+        "indexed": true,
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "indexed": true,
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "indexed": false,
+        "internalType": "uint192",
+        "name": "newTp",
+        "type": "uint192"
+      }
+    ],
+    "name": "TpUpdated",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      {
+        "indexed": false,
+        "internalType": "uint16",
+        "name": "value",
+        "type": "uint16"
+      }
+    ],
+    "name": "TriggerTimeoutUpdated",
+    "type": "event"
+  },
+  {
+    "inputs": [],
+    "name": "DELEGATION_TYPEHASH",
+    "outputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "DOMAIN_SEPARATOR",
+    "outputs": [
+      {
+        "internalType": "bytes32",
+        "name": "",
+        "type": "bytes32"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "_msgSender",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      }
+    ],
+    "name": "cancelOpenLimitOrder",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint16",
+        "name": "closePercentage",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint192",
+        "name": "marketPrice",
+        "type": "uint192"
+      },
+      {
+        "internalType": "uint32",
+        "name": "slippageP",
+        "type": "uint32"
+      }
+    ],
+    "name": "closeTradeMarket",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_order",
+        "type": "uint256"
+      },
+      {
+        "internalType": "bool",
+        "name": "retry",
+        "type": "bool"
+      }
+    ],
+    "name": "closeTradeMarketTimeout",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "name": "delegatableNonces",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "bytes",
+        "name": "call_data",
+        "type": "bytes"
+      }
+    ],
+    "name": "delegatedAction",
+    "outputs": [
+      {
+        "internalType": "bytes",
+        "name": "",
+        "type": "bytes"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "delegator",
+        "type": "address"
+      }
+    ],
+    "name": "delegations",
+    "outputs": [
+      {
+        "internalType": "address",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "done",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "enum IOstiumTradingStorage.LimitOrder",
+        "name": "orderType",
+        "type": "uint8"
+      },
+      {
+        "internalType": "address",
+        "name": "trader",
+        "type": "address"
+      },
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "priceTimestamp",
+        "type": "uint256"
+      }
+    ],
+    "name": "executeAutomationOrder",
+    "outputs": [
+      {
+        "internalType": "enum IOstiumTrading.AutomationOrderStatus",
+        "name": "",
+        "type": "uint8"
+      }
+    ],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "contract IOstiumRegistry",
+        "name": "_registry",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "_maxAllowedCollateral",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint16",
+        "name": "_marketOrdersTimeout",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint16",
+        "name": "_triggerTimeout",
+        "type": "uint16"
+      }
+    ],
+    "name": "initialize",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "isDone",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "isPaused",
+    "outputs": [
+      {
+        "internalType": "bool",
+        "name": "",
+        "type": "bool"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "marketOrdersTimeout",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "maxAllowedCollateral",
+    "outputs": [
+      {
+        "internalType": "uint256",
+        "name": "",
+        "type": "uint256"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "components": [
+          {
+            "internalType": "uint256",
+            "name": "collateral",
+            "type": "uint256"
+          },
+          {
+            "internalType": "uint192",
+            "name": "openPrice",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint192",
+            "name": "tp",
+            "type": "uint192"
+          },
+          {
+            "internalType": "uint192",
+            "name": "sl",
+            "type": "uint192"
+          },
+          {
+            "internalType": "address",
+            "name": "trader",
+            "type": "address"
+          },
+          {
+            "internalType": "uint32",
+            "name": "leverage",
+            "type": "uint32"
+          },
+          {
+            "internalType": "uint16",
+            "name": "pairIndex",
+            "type": "uint16"
+          },
+          {
+            "internalType": "uint8",
+            "name": "index",
+            "type": "uint8"
+          },
+          {
+            "internalType": "bool",
+            "name": "buy",
+            "type": "bool"
+          },
+          {
+            "internalType": "bool",
+            "name": "isDayTrade",
+            "type": "bool"
+          }
+        ],
+        "internalType": "struct IOstiumTradingStorage.Trade",
+        "name": "t",
+        "type": "tuple"
+      },
+      {
+        "components": [
+          {
+            "internalType": "address",
+            "name": "builder",
+            "type": "address"
+          },
+          {
+            "internalType": "uint32",
+            "name": "builderFee",
+            "type": "uint32"
+          }
+        ],
+        "internalType": "struct IOstiumTradingStorage.BuilderFee",
+        "name": "bf",
+        "type": "tuple"
+      },
+      {
+        "internalType": "enum IOstiumTradingStorage.OpenOrderType",
+        "name": "orderType",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "slippageP",
+        "type": "uint256"
+      }
+    ],
+    "name": "openTrade",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "_order",
+        "type": "uint256"
+      }
+    ],
+    "name": "openTradeMarketTimeout",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "pause",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "registry",
+    "outputs": [
+      {
+        "internalType": "contract IOstiumRegistry",
+        "name": "",
+        "type": "address"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "removeAmount",
+        "type": "uint256"
+      }
+    ],
+    "name": "removeCollateral",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "removeDelegate",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "delegate",
+        "type": "address"
+      }
+    ],
+    "name": "setDelegate",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "address",
+        "name": "delegator",
+        "type": "address"
+      },
+      {
+        "internalType": "address",
+        "name": "delegate",
+        "type": "address"
+      },
+      {
+        "internalType": "uint256",
+        "name": "nonce",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint256",
+        "name": "expiry",
+        "type": "uint256"
+      },
+      {
+        "internalType": "uint8",
+        "name": "v",
+        "type": "uint8"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "r",
+        "type": "bytes32"
+      },
+      {
+        "internalType": "bytes32",
+        "name": "s",
+        "type": "bytes32"
+      }
+    ],
+    "name": "setDelegateWithSignature",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "setMarketOrdersTimeout",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "setMaxAllowedCollateral",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint256",
+        "name": "value",
+        "type": "uint256"
+      }
+    ],
+    "name": "setTriggerTimeout",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint256",
+        "name": "topUpAmount",
+        "type": "uint256"
+      }
+    ],
+    "name": "topUpCollateral",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [],
+    "name": "triggerTimeout",
+    "outputs": [
+      {
+        "internalType": "uint16",
+        "name": "",
+        "type": "uint16"
+      }
+    ],
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint192",
+        "name": "price",
+        "type": "uint192"
+      },
+      {
+        "internalType": "uint192",
+        "name": "tp",
+        "type": "uint192"
+      },
+      {
+        "internalType": "uint192",
+        "name": "sl",
+        "type": "uint192"
+      }
+    ],
+    "name": "updateOpenLimitOrder",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint192",
+        "name": "newSl",
+        "type": "uint192"
+      }
+    ],
+    "name": "updateSl",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "inputs": [
+      {
+        "internalType": "uint16",
+        "name": "pairIndex",
+        "type": "uint16"
+      },
+      {
+        "internalType": "uint8",
+        "name": "index",
+        "type": "uint8"
+      },
+      {
+        "internalType": "uint192",
+        "name": "newTp",
+        "type": "uint192"
+      }
+    ],
+    "name": "updateTp",
+    "outputs": [],
+    "stateMutability": "nonpayable",
+    "type": "function"
+  }
+];
+
+// src/encoder.ts
+function tx(to, data) {
+  return { to, data, value: 0n };
+}
+function encodeOpenTrade(trade, builderFee, orderType, slippageP, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "openTrade",
+    args: [
+      {
+        collateral: trade.collateral,
+        openPrice: trade.openPrice,
+        tp: trade.tp,
+        sl: trade.sl,
+        trader: trade.trader,
+        leverage: Number(trade.leverage),
+        pairIndex: Number(trade.pairIndex),
+        index: Number(trade.index),
+        buy: trade.buy,
+        isDayTrade: trade.isDayTrade ?? false
+      },
+      {
+        builder: builderFee.builder,
+        builderFee: Number(builderFee.builderFee)
+      },
+      orderType,
+      slippageP
+    ]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeCloseTradeMarket(pairIndex, index, closePercentage, marketPrice, slippageP, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "closeTradeMarket",
+    args: [Number(pairIndex), Number(index), Number(closePercentage), marketPrice, Number(slippageP)]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeCancelLimitOrder(pairIndex, orderIndex, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "cancelOpenLimitOrder",
+    args: [Number(pairIndex), Number(orderIndex)]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeCloseTradeMarketTimeout(orderId, retry, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "closeTradeMarketTimeout",
+    args: [orderId, retry]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeOpenTradeMarketTimeout(orderId, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "openTradeMarketTimeout",
+    args: [orderId]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeUpdateOpenLimitOrder(pairIndex, orderIndex, price, tp, sl, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "updateOpenLimitOrder",
+    args: [Number(pairIndex), Number(orderIndex), price, tp, sl]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeUpdateTp(pairIndex, index, newTp, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "updateTp",
+    args: [Number(pairIndex), Number(index), newTp]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeUpdateSl(pairIndex, index, newSl, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "updateSl",
+    args: [Number(pairIndex), Number(index), newSl]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeTopUpCollateral(pairIndex, index, amount, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "topUpCollateral",
+    args: [Number(pairIndex), Number(index), amount]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeRemoveCollateral(pairIndex, index, amount, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "removeCollateral",
+    args: [Number(pairIndex), Number(index), amount]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeSetDelegate(delegateAddress, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "setDelegate",
+    args: [viem.getAddress(delegateAddress)]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeRemoveDelegate(tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "removeDelegate",
+    args: []
+  });
+  return tx(tradingAddress, data);
+}
+function encodeDelegatedAction(traderAddress, callData, tradingAddress) {
+  const data = viem.encodeFunctionData({
+    abi: TRADING_ABI,
+    functionName: "delegatedAction",
+    args: [viem.getAddress(traderAddress), callData]
+  });
+  return tx(tradingAddress, data);
+}
+function encodeUsdcApprove(spender, amount, usdcAddress) {
+  const data = viem.encodeFunctionData({
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [viem.getAddress(spender), amount]
+  });
+  return tx(usdcAddress, data);
+}
+
+// src/signer/delegated.ts
+var DelegatedSignerStrategy = class {
+  traderAddress;
+  constructor(traderAddress) {
+    this.traderAddress = traderAddress;
+  }
+  prepare(encoded) {
+    return encodeDelegatedAction(this.traderAddress, encoded.data, encoded.to);
+  }
+};
+
+// src/signer/index.ts
+function createSigner(config, traderAddress, selfGasless = false) {
+  if (isDelegated(config) || selfGasless) {
+    return new DelegatedSignerStrategy(traderAddress);
+  }
+  return new SelfSignerStrategy(traderAddress);
+}
+function classifySubmitError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  if (lower.includes("execution reverted") || lower.includes("reverted with reason") || lower.includes("contract function") || lower.includes("revert")) {
+    return new OstiumError(`Contract reverted: ${msg}`, "CONTRACT_ERROR" /* CONTRACT_ERROR */, err);
+  }
+  if (lower.includes("fetch") || lower.includes("etimedout") || lower.includes("econnrefused") || lower.includes("enotfound") || lower.includes("network") || lower.includes("timeout") || lower.includes("connection")) {
+    return new OstiumError(`Network error: ${msg}`, "NETWORK_ERROR" /* NETWORK_ERROR */, err);
+  }
+  return new OstiumError(
+    `Transaction submission failed: ${msg}`,
+    "SUBMISSION_FAILED" /* SUBMISSION_FAILED */,
+    err
+  );
+}
+var SelfSubmissionStrategy = class {
+  effectiveSender;
+  send;
+  constructor(config, testnet) {
+    if (!config.rpcUrl) {
+      throw new OstiumError(
+        "rpcUrl is required for self-submission mode",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    const chain = testnet ? chains.arbitrumSepolia : chains.arbitrum;
+    const account = accounts.privateKeyToAccount(config.privateKey);
+    const walletClient = viem.createWalletClient({ account, chain, transport: viem.http(config.rpcUrl) });
+    this.effectiveSender = account.address;
+    this.send = (encoded) => walletClient.sendTransaction({ account, to: encoded.to, data: encoded.data, value: encoded.value });
+  }
+  async submit(encoded) {
+    try {
+      const txHash = await this.send(encoded);
+      return { txHash };
+    } catch (err) {
+      throw classifySubmitError(err);
+    }
+  }
+};
+function classifyGaslessError(err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const lower = msg.toLowerCase();
+  if (lower.includes("execution reverted") || lower.includes("reverted with reason") || lower.includes("revert") || lower.includes("userop reverted") || lower.includes("aa")) {
+    return new OstiumError(`Contract reverted: ${msg}`, "CONTRACT_ERROR" /* CONTRACT_ERROR */, err);
+  }
+  if (lower.includes("429") || lower.includes("rate limit") || lower.includes("too many requests")) {
+    return new OstiumError(
+      `Pimlico rate limit exceeded \u2014 retry after 60 seconds. ${msg}`,
+      "NETWORK_ERROR" /* NETWORK_ERROR */,
+      err
+    );
+  }
+  if (lower.includes("sponsorship") || lower.includes("policy")) {
+    return new OstiumError(
+      `Pimlico sponsorship policy error \u2014 check sponsorshipPolicyId config. ${msg}`,
+      "INVALID_CONFIG" /* INVALID_CONFIG */,
+      err
+    );
+  }
+  if (lower.includes("fetch") || lower.includes("etimedout") || lower.includes("econnrefused") || lower.includes("network") || lower.includes("timeout") || lower.includes("bundle") || lower.includes("connection")) {
+    return new OstiumError(`Network error: ${msg}`, "NETWORK_ERROR" /* NETWORK_ERROR */, err);
+  }
+  return new OstiumError(
+    `Gasless submission failed: ${msg}`,
+    "SUBMISSION_FAILED" /* SUBMISSION_FAILED */,
+    err
+  );
+}
+var GaslessSubmissionStrategy = class _GaslessSubmissionStrategy {
+  effectiveSender;
+  testnet;
+  pimlicoUrl;
+  sponsorshipPolicyId;
+  // Cached Safe account — derived once in create(), reused on every submit().
+  safeAccount;
+  constructor(testnet, pimlicoUrl, sponsorshipPolicyId, safeAccount) {
+    this.testnet = testnet;
+    this.pimlicoUrl = pimlicoUrl;
+    this.sponsorshipPolicyId = sponsorshipPolicyId;
+    this.safeAccount = safeAccount;
+    this.effectiveSender = safeAccount.address;
+  }
+  static async create(config, testnet) {
+    if (!config.pimlicoUrl) {
+      throw new OstiumError(
+        "pimlicoUrl is required for gasless mode",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    const chain = testnet ? chains.arbitrumSepolia : chains.arbitrum;
+    const pimlicoUrl = config.pimlicoUrl;
+    const chainRpc = config.rpcUrl ?? (testnet ? "https://sepolia-rollup.arbitrum.io/rpc" : "https://arb1.arbitrum.io/rpc");
+    const rpcTransport = viem.http(chainRpc);
+    const publicClient = viem.createPublicClient({ chain, transport: rpcTransport });
+    const owner = accounts.privateKeyToAccount(config.privateKey);
+    try {
+      const safeAccount = await accounts$1.toSafeSmartAccount({
+        client: publicClient,
+        owners: [owner],
+        entryPoint: {
+          address: accountAbstraction.entryPoint07Address,
+          version: "0.7"
+        },
+        version: "1.4.1"
+      });
+      return new _GaslessSubmissionStrategy(testnet, pimlicoUrl, config.sponsorshipPolicyId, safeAccount);
+    } catch (err) {
+      throw new OstiumError(
+        `Failed to derive Safe smart account address: ${err instanceof Error ? err.message : String(err)}`,
+        "INVALID_CONFIG" /* INVALID_CONFIG */,
+        err
+      );
+    }
+  }
+  async submit(encoded) {
+    const chain = this.testnet ? chains.arbitrumSepolia : chains.arbitrum;
+    const pimlicoClient = pimlico.createPimlicoClient({
+      transport: viem.http(this.pimlicoUrl),
+      entryPoint: {
+        address: accountAbstraction.entryPoint07Address,
+        version: "0.7"
+      }
+    });
+    try {
+      const smartAccountClient = permissionless.createSmartAccountClient({
+        account: this.safeAccount,
+        chain,
+        bundlerTransport: viem.http(this.pimlicoUrl),
+        paymaster: pimlicoClient,
+        userOperation: {
+          estimateFeesPerGas: async () => (await pimlicoClient.getUserOperationGasPrice()).fast
+        },
+        ...this.sponsorshipPolicyId && {
+          paymasterContext: {
+            sponsorshipPolicyId: this.sponsorshipPolicyId
+          }
+        }
+      });
+      const txHash = await smartAccountClient.sendTransaction({
+        to: encoded.to,
+        data: encoded.data,
+        value: encoded.value
+      });
+      return { txHash, smartAccountAddress: this.safeAccount.address };
+    } catch (err) {
+      throw classifyGaslessError(err);
+    }
+  }
+};
+
+// src/submitter/index.ts
+async function createSubmitter(config, testnet) {
+  if (isGasless(config)) {
+    return GaslessSubmissionStrategy.create(config, testnet);
+  }
+  if (!config.rpcUrl) {
+    throw new Error("rpcUrl is required for self-submission mode");
+  }
+  return new SelfSubmissionStrategy(config, testnet);
+}
+
+// src/data/config.ts
+var DEFAULT_SUBGRAPH_ENDPOINT = "https://api.subgraph.ormilabs.com/api/public/67a599d5-c8d2-4cc4-9c4d-2975a97bc5d8/subgraphs/ost-prod/live/gn";
+var DEFAULT_SUBGRAPH_ENDPOINT_TESTNET = "https://api.subgraph.ormilabs.com/api/public/67a599d5-c8d2-4cc4-9c4d-2975a97bc5d8/subgraphs/ost-sep/live/gn";
+var DEFAULT_BUILDER_API_URL = "https://builder.ostium.io";
+
+// src/data/errors.ts
+var OstiumSubgraphErrorCode = /* @__PURE__ */ ((OstiumSubgraphErrorCode2) => {
+  OstiumSubgraphErrorCode2["INVALID_CONFIG"] = "INVALID_CONFIG";
+  OstiumSubgraphErrorCode2["INVALID_PARAMS"] = "INVALID_PARAMS";
+  OstiumSubgraphErrorCode2["FETCH_FAILED"] = "FETCH_FAILED";
+  OstiumSubgraphErrorCode2["NOT_FOUND"] = "NOT_FOUND";
+  OstiumSubgraphErrorCode2["PARSE_ERROR"] = "PARSE_ERROR";
+  return OstiumSubgraphErrorCode2;
+})(OstiumSubgraphErrorCode || {});
+var OstiumSubgraphError = class extends Error {
+  constructor(message, code, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "OstiumSubgraphError";
+  }
+  code;
+  cause;
+};
+
+// src/data/queries.ts
+var PAIR_FIELDS = `
+    id
+    from
+    to
+    maxLeverage
+    overnightMaxLeverage
+    takerFeeP
+    maxOI
+    longOI
+    shortOI
+    group { id name maxLeverage }
+    lastUpdateTimestamp
+    buyVolume
+    sellVolume
+    decayRate
+    netVolThreshold
+    priceImpactK
+    accRolloverLong
+    accRolloverShort
+    lastRolloverBlock
+    lastRolloverLongPure
+    brokerPremium
+    isNegativeRolloverAllowed
+    lastTradePrice
+    spreadP`;
+var GetPairsAndGroupsQuery = `
+query GetPairsAndGroups {
+  pairs(orderBy: id, orderDirection: asc, subgraphError: allow) {
+    ${PAIR_FIELDS}
+  }
+  groups { id name maxLeverage }
+}`;
+var PAIR_FULL = `
+    pair {
+      id from to
+      maxLeverage overnightMaxLeverage
+      takerFeeP
+      maxOI longOI shortOI
+      group { id name maxLeverage }
+      lastUpdateTimestamp
+      buyVolume sellVolume decayRate netVolThreshold priceImpactK
+      accRolloverLong accRolloverShort lastRolloverBlock lastRolloverLongPure
+      brokerPremium isNegativeRolloverAllowed lastTradePrice
+    }`;
+var TRADE_CORE = `
+    id tradeID trader
+    isOpen isBuy isDayTrade
+    index tradeType
+    collateral notional tradeNotional leverage highestLeverage
+    openPrice stopLossPrice takeProfitPrice
+    rollover timestamp`;
+var GetTraderOpenTradesQuery = `
+query GetTraderOpenTrades($trader: String!, $skip: Int!, $first: Int!) {
+  trades(
+    where: { isOpen: true, trader: $trader }
+    skip: $skip first: $first
+    orderBy: timestamp orderDirection: desc
+  ) {
+    ${TRADE_CORE}
+    ${PAIR_FULL}
+  }
+}`;
+var ORDER_FIELDS = `
+    id tradeID limitID trader
+    pair { id from to group { id name } }
+    orderAction orderType isBuy
+    isPending isCancelled cancelReason
+    collateral notional tradeNotional leverage
+    price priceAfterImpact priceImpactP
+    vaultFee devFee oracleFee rolloverFee liquidationFee
+    builder builderFee
+    profitPercent totalProfitPercent amountSentToTrader
+    closePercent
+    initiatedTx initiatedBlock initiatedAt
+    executedTx executedBlock executedAt`;
+function buildExecutedFillsQuery(opts) {
+  const args = ["$skip: Int!", "$first: Int!"];
+  const conditions = ["isPending: false", "isCancelled: false"];
+  if (opts.hasTrader) {
+    args.push("$trader: String!");
+    conditions.push("trader: $trader");
+  }
+  if (opts.hasPairId) {
+    args.push("$pairId: String!");
+    conditions.push("pair: $pairId");
+  }
+  if (opts.hasTimeRange) {
+    args.push("$startSec: BigInt!", "$endSec: BigInt!");
+    conditions.push("executedAt_gte: $startSec", "executedAt_lte: $endSec");
+  }
+  return `
+query GetExecutedFills(${args.join(", ")}) {
+  orders(
+    where: { ${conditions.join(", ")} }
+    skip: $skip first: $first
+    orderBy: executedAt orderDirection: desc
+  ) { ${ORDER_FIELDS} }
+}`;
+}
+function buildGetOrdersQuery(opts) {
+  const args = ["$skip: Int!", "$first: Int!"];
+  const conditions = [];
+  if (opts.hasOrderIds) {
+    args.push("$ids: [String!]!");
+    conditions.push("id_in: $ids");
+  }
+  if (opts.hasInitiatedTxHashes) {
+    args.push("$txHashes: [String!]!");
+    conditions.push("initiatedTx_in: $txHashes");
+  }
+  if (opts.hasTrader) {
+    args.push("$trader: String!");
+    conditions.push("trader: $trader");
+  }
+  const where = conditions.length > 0 ? `where: { ${conditions.join(", ")} }` : "";
+  return `
+query GetOrders(${args.join(", ")}) {
+  orders(
+    ${where}
+    skip: $skip first: $first
+    orderBy: initiatedAt orderDirection: desc
+  ) { ${ORDER_FIELDS} }
+}`;
+}
+var LIMIT_FIELDS = `
+    id uniqueId orderId trader
+    pair { id from to group { id name } }
+    isBuy limitType isActive executionStarted
+    collateral notional tradeNotional leverage
+    openPrice takeProfitPrice stopLossPrice
+    block initiatedAt updatedAt`;
+var GetTraderActiveLimitsQuery = `
+query GetTraderActiveLimits($trader: String!, $skip: Int!, $first: Int!) {
+  limits(
+    where: { isActive: true, trader: $trader }
+    skip: $skip first: $first
+    orderBy: updatedAt orderDirection: desc
+  ) { ${LIMIT_FIELDS} }
+}`;
+
+// src/data/internal/pagination.ts
+async function paginateAll(fetcher, batchSize = 1e3, max = Infinity) {
+  const results = [];
+  let skip = 0;
+  while (results.length < max) {
+    const remaining = max - results.length;
+    const fetchSize = Math.min(batchSize, remaining);
+    const page = await fetcher(skip, fetchSize);
+    results.push(...page);
+    if (page.length < fetchSize) break;
+    skip += fetchSize;
+  }
+  return results;
+}
+
+// src/data/internal/precision.ts
+var USDC_DECIMALS = 6;
+var TOKEN_DECIMALS = 18;
+var LEVERAGE_DECIMALS = 2;
+
+// src/data/internal/decimal.ts
+function formatUsdc(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.includes(".")) return parseFloat(value);
+  return Number(viem.formatUnits(BigInt(value), USDC_DECIMALS));
+}
+function formatTokens(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.includes(".")) return parseFloat(value);
+  return Number(viem.formatUnits(BigInt(value), TOKEN_DECIMALS));
+}
+function formatLeverage(value) {
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && value.includes(".")) return parseFloat(value);
+  return Number(viem.formatUnits(BigInt(value), LEVERAGE_DECIMALS));
+}
+function parseUsdc2(value) {
+  return viem.parseUnits(value.toString(), USDC_DECIMALS);
+}
+function parseTokens(value) {
+  return viem.parseUnits(value.toString(), TOKEN_DECIMALS);
+}
+function parseLeverage2(value) {
+  return viem.parseUnits(value.toString(), LEVERAGE_DECIMALS);
+}
+function getMaxLeverage(trade) {
+  return trade.pair.maxLeverage && trade.pair.maxLeverage !== "0" ? trade.pair.maxLeverage : trade.pair.group?.maxLeverage ?? "1";
+}
+function timeElapsedSince(pair) {
+  const now = Math.floor(Date.now() / 1e3);
+  const last = parseInt(pair.lastUpdateTimestamp ?? "0") || parseInt(pair.lastFundingTime ?? "0");
+  return (now - last).toString();
+}
+
+// src/data/internal/calculations.ts
+var EMPTY_PNL = {
+  pnl: 0,
+  pnlPercent: 0,
+  rollover: 0,
+  netPnl: 0,
+  netValue: 0,
+  liquidationPrice: 0,
+  priceAfterImpact: 0
+};
+function getRolloverAccumulator(pair, isBuy, blockNumber) {
+  const accRollover = isBuy ? pair.accRolloverLong ?? "0" : pair.accRolloverShort ?? "0";
+  return formulae.GetCurrentRolloverFee(
+    accRollover,
+    pair.lastRolloverBlock ?? "0",
+    pair.brokerPremium ?? "0",
+    pair.lastRolloverLongPure ?? "0",
+    isBuy,
+    pair.isNegativeRolloverAllowed ?? false,
+    blockNumber.toString()
+  );
+}
+function getTradeRolloverFeeRaw(trade, currentRolloverAccumulator) {
+  return BigInt(
+    formulae.GetTradeRolloverFee(
+      trade.rollover,
+      currentRolloverAccumulator,
+      trade.collateral,
+      trade.leverage
+    )
+  );
+}
+function getLiquidationPrice(trade, rolloverRaw) {
+  if (!trade.leverage || trade.leverage === "0") return 0;
+  if (!trade.openPrice || trade.openPrice === "0") return 0;
+  if (!trade.collateral || trade.collateral === "0") return 0;
+  try {
+    const maxLeverage = formulae.GetEffectiveMaxLeverage(
+      getMaxLeverage(trade),
+      trade.pair.overnightMaxLeverage ?? "0",
+      trade.isDayTrade ?? false
+    );
+    return formatTokens(
+      formulae.GetTradeLiquidationPrice(
+        trade.openPrice,
+        trade.isBuy,
+        trade.collateral,
+        trade.leverage,
+        rolloverRaw.toString(),
+        "0",
+        // funding excluded
+        maxLeverage
+      )
+    );
+  } catch {
+    return 0;
+  }
+}
+function getPriceImpact(marketPrice, isBuy, isOpen, pair, collateral, leverage) {
+  if (!marketPrice.mid) return { priceImpactP: "0", priceAfterImpact: "0" };
+  return formulae.CalculateDynamicPriceImpact(
+    parseTokens(marketPrice.mid).toString(),
+    parseTokens(marketPrice.ask).toString(),
+    parseTokens(marketPrice.bid).toString(),
+    isOpen,
+    isBuy,
+    parseUsdc2(collateral).toString(),
+    parseLeverage2(leverage).toString(),
+    pair.buyVolume ?? "0",
+    pair.sellVolume ?? "0",
+    pair.decayRate ?? "0",
+    timeElapsedSince(pair),
+    pair.netVolThreshold ?? "0",
+    pair.priceImpactK ?? "0"
+  );
+}
+function getTradePnL(trade, marketPrice, blockNumber) {
+  if (!trade?.pair || !marketPrice?.mid || !blockNumber) return EMPTY_PNL;
+  const rolloverAcc = getRolloverAccumulator(trade.pair, trade.isBuy, blockNumber);
+  const rolloverRaw = getTradeRolloverFeeRaw(trade, rolloverAcc);
+  const liquidationPrice = getLiquidationPrice(trade, rolloverRaw);
+  const impactResult = getPriceImpact(
+    marketPrice,
+    trade.isBuy,
+    false,
+    trade.pair,
+    formatUsdc(trade.collateral),
+    formatLeverage(trade.leverage)
+  );
+  const priceForPnL = parseTokens(marketPrice.mid).toString();
+  const pnlRaw = BigInt(
+    formulae.CurrentTradeProfitRaw(
+      trade.openPrice,
+      priceForPnL,
+      trade.isBuy,
+      trade.leverage,
+      trade.highestLeverage,
+      trade.collateral
+    )
+  );
+  const totalProfitRaw = BigInt(
+    formulae.CurrentTotalProfitRaw(
+      trade.openPrice,
+      priceForPnL,
+      trade.isBuy,
+      trade.leverage,
+      trade.highestLeverage,
+      trade.collateral,
+      rolloverRaw.toString(),
+      "0"
+      // funding excluded
+    )
+  );
+  const pnlPercentRaw = BigInt(
+    formulae.CurrentTotalProfitP(totalProfitRaw.toString(), trade.collateral)
+  );
+  return {
+    pnl: formatUsdc(pnlRaw),
+    pnlPercent: formatUsdc(pnlPercentRaw),
+    rollover: formatUsdc(rolloverRaw),
+    netPnl: formatUsdc(totalProfitRaw),
+    netValue: formatUsdc(totalProfitRaw) + formatUsdc(trade.collateral),
+    liquidationPrice,
+    priceAfterImpact: formatTokens(impactResult.priceAfterImpact)
+  };
+}
+
+// src/data/internal/pair-names.ts
+var PAIR_NAME_MAP = {
+  CL: "WTI",
+  HG: "XCU",
+  SPX: "US500",
+  NDX: "US100",
+  DJI: "US30",
+  DAX: "GER40",
+  FTSE: "UK100",
+  HSI: "HK50",
+  NIK: "JP225"
+};
+function normalizePairName(symbol) {
+  return PAIR_NAME_MAP[symbol] ?? symbol;
+}
+
+// src/data/internal/pricing.ts
+async function fetchLivePrices(builderApiUrl) {
+  const res = await fetch(`${builderApiUrl}/v1/prices`);
+  if (res.status === 503) return {};
+  if (!res.ok) {
+    throw new Error(`Live prices endpoint returned ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  if (!Array.isArray(json.prices)) {
+    throw new Error("Live prices endpoint returned an unexpected payload");
+  }
+  const result = {};
+  for (const item of json.prices) {
+    if (!item.from || !item.to) continue;
+    result[`${item.from}/${item.to}`] = {
+      mid: item.mid,
+      bid: item.bid,
+      ask: item.ask,
+      isMarketOpen: item.isMarketOpen ?? true,
+      isDayTradingClosed: item.isDayTradingClosed ?? false,
+      secondsToToggleIsDayTradingClosed: item.secondsToToggleIsDayTradingClosed ?? -1
+    };
+  }
+  return result;
+}
+function rawTickToPublic(item) {
+  const from = normalizePairName(item.from);
+  const to = normalizePairName(item.to);
+  return {
+    feedId: item.feed_id,
+    pair: `${from}-${to}`,
+    from,
+    to,
+    bid: item.bid,
+    mid: item.mid,
+    ask: item.ask,
+    isMarketOpen: item.isMarketOpen ?? true,
+    isDayTradingClosed: item.isDayTradingClosed ?? false,
+    secondsToToggleIsDayTradingClosed: item.secondsToToggleIsDayTradingClosed ?? -1,
+    timestampSeconds: item.timestampSeconds
+  };
+}
+async function fetchCandles(builderApiUrl, rawPair, fromMs, toMs, resolution) {
+  const res = await fetch(`${builderApiUrl}/v1/ohlc`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      pair: rawPair,
+      fromTimestampSeconds: Math.floor(fromMs / 1e3),
+      toTimestampSeconds: Math.floor(toMs / 1e3),
+      resolution
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`OHLC endpoint returned ${res.status} ${res.statusText}`);
+  }
+  const json = await res.json();
+  return json.data.map((c) => ({
+    pairFrom: normalizePairName(c.from),
+    pairTo: normalizePairName(c.to),
+    time: c.time,
+    open: c.open,
+    high: c.high,
+    low: c.low,
+    close: c.close
+  }));
+}
+var OstiumPriceStream = class _OstiumPriceStream {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  ws;
+  // ws.WebSocket — typed as any to stay compatible with both Node and Bun
+  tickHandlers = /* @__PURE__ */ new Set();
+  snapshotHandlers = /* @__PURE__ */ new Set();
+  /** pairId (string) → raw "FROM-TO" name for the WS API. */
+  pairRawNameCache;
+  constructor(ws, pairRawNameCache, initialSubscribeRawPairs) {
+    this.ws = ws;
+    this.pairRawNameCache = pairRawNameCache;
+    if (initialSubscribeRawPairs?.length) {
+      ws.once("open", () => {
+        ws.send(JSON.stringify({ type: "subscribe", pairs: initialSubscribeRawPairs }));
+      });
+    }
+    ws.on("message", (data) => {
+      let msg;
+      try {
+        msg = JSON.parse(typeof data === "string" ? data : data.toString());
+      } catch {
+        return;
+      }
+      if (msg.type === "snapshot" && Array.isArray(msg.data)) {
+        const ticks = msg.data.map(rawTickToPublic);
+        for (const h of this.snapshotHandlers) h(ticks);
+      } else if (msg.type === "tick" && msg.data) {
+        const tick = rawTickToPublic(msg.data);
+        for (const h of this.tickHandlers) h(tick);
+      }
+    });
+  }
+  /**
+   * Open a WebSocket connection to the live price stream.
+   *
+   * Uses the `ws` package which correctly handles case-insensitive `Connection`
+   * header values (required for Cloudflare-proxied endpoints).
+   *
+   * @param builderApiUrl    - Base URL (e.g. `"https://builder.ostium.io"`). The `http`/`https`
+   *                           scheme is automatically converted to `ws`/`wss`.
+   * @param rawPairs         - Optional raw `"FROM-TO"` names (from
+   *                           `OstiumSubgraphClient.streamPrices` pairIds). Sent as
+   *                           `{ type: "subscribe", pairs }` after the socket opens.
+   * @param pairRawNameCache - pairId → raw name map; passed in by the subgraph client so
+   *                           `subscribe` / `unsubscribe` can accept pairIds.
+   */
+  static connect(builderApiUrl, rawPairs, pairRawNameCache = /* @__PURE__ */ new Map()) {
+    const base = builderApiUrl.replace(/\/$/, "").replace(/^https?:\/\//, (match) => match === "https://" ? "wss://" : "ws://");
+    const url = `${base}/v1/prices/stream`;
+    const initial = rawPairs && rawPairs.length > 0 ? rawPairs : void 0;
+    const ws = new WS__default.default(url, {
+      headers: { "User-Agent": "ostium-sdk", "Accept": "*/*" }
+    });
+    return new _OstiumPriceStream(ws, pairRawNameCache, initial);
+  }
+  /**
+   * Register a callback that fires on every incoming price tick.
+   * Returns an unsubscribe function.
+   */
+  onTick(handler) {
+    this.tickHandlers.add(handler);
+    return () => {
+      this.tickHandlers.delete(handler);
+    };
+  }
+  /**
+   * Register a callback that fires once with the full snapshot sent on connect.
+   * Returns an unsubscribe function.
+   */
+  onSnapshot(handler) {
+    this.snapshotHandlers.add(handler);
+    return () => {
+      this.snapshotHandlers.delete(handler);
+    };
+  }
+  /** Register a one-time callback that fires when the connection is established. */
+  onOpen(handler) {
+    this.ws.once("open", handler);
+    return this;
+  }
+  /** Register an error callback. */
+  onError(handler) {
+    this.ws.on("error", handler);
+    return this;
+  }
+  /** Register a callback that fires when the connection closes. */
+  onClose(handler) {
+    this.ws.on("close", handler);
+    return this;
+  }
+  /**
+   * Add pairs to the active filter. Accepts the same `pairId` values used
+   * throughout the SDK (numeric string or number).
+   * Sends `{ type: "subscribe", pairs: [...rawNames] }` to the server.
+   */
+  subscribe(pairIds) {
+    this.send({ type: "subscribe", pairs: this.resolveRawNames(pairIds) });
+    return this;
+  }
+  /**
+   * Remove pairs from the active filter. Accepts the same `pairId` values used
+   * throughout the SDK.
+   * Sends `{ type: "unsubscribe", pairs: [...rawNames] }` to the server.
+   */
+  unsubscribe(pairIds) {
+    this.send({ type: "unsubscribe", pairs: this.resolveRawNames(pairIds) });
+    return this;
+  }
+  /** Close the WebSocket connection. */
+  close() {
+    this.ws.close();
+  }
+  /** Underlying WebSocket ready state (`0=CONNECTING`, `1=OPEN`, `2=CLOSING`, `3=CLOSED`). */
+  get readyState() {
+    return this.ws.readyState;
+  }
+  resolveRawNames(pairIds) {
+    return pairIds.map((id) => {
+      const cached = this.pairRawNameCache.get(String(id));
+      return cached ?? String(id);
+    });
+  }
+  send(msg) {
+    if (this.ws.readyState === WS__default.default.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+};
+
+// src/data/internal/formatters.ts
+var MIN_NOTIONAL = "5.0";
+var MIN_NOTIONAL_NUM = 5;
+var BLOCKS_PER_SECOND_ARBITRUM = 4;
+var ROLLOVER_RATE_HOURS = 8;
+function lowerHex(value) {
+  if (!value) return null;
+  const lower = value.toLowerCase();
+  return lower.startsWith("0x") ? lower : `0x${lower}`;
+}
+function pairMaxLeverage(pair) {
+  const maxLevString = !pair.maxLeverage || pair.maxLeverage === "0" ? pair.group.maxLeverage ?? "0" : pair.maxLeverage;
+  return formatLeverage(maxLevString);
+}
+function maxWithdrawForPosition(collateral, currentLeverage, maxLeverage) {
+  if (collateral <= 0) return 0;
+  if (currentLeverage <= 0) return 0;
+  if (maxLeverage <= 0) return 0;
+  if (currentLeverage >= maxLeverage) return 0;
+  const max = collateral * (1 - currentLeverage / maxLeverage);
+  if (max < 0) return 0;
+  if (max > collateral) return collateral;
+  return max;
+}
+function formatPair(raw, price) {
+  const lastPrice = formatTokens(raw.lastTradePrice);
+  const mid = price?.mid;
+  const refPrice = mid && mid > 0 ? mid : lastPrice;
+  const buyOI_usd = formatTokens(raw.longOI) * lastPrice;
+  const sellOI_usd = formatTokens(raw.shortOI) * lastPrice;
+  const maxOI_usd = formatUsdc(raw.maxOI);
+  const minSz = refPrice > 0 ? MIN_NOTIONAL_NUM / refPrice : 0;
+  const maxBSz = refPrice > 0 ? Math.max(0, (maxOI_usd - buyOI_usd) / refPrice) : 0;
+  const maxSSz = refPrice > 0 ? Math.max(0, (maxOI_usd - sellOI_usd) / refPrice) : 0;
+  const rolloverRate = getRolloverRateDisplay(raw);
+  return {
+    pairId: String(raw.id),
+    pairTo: normalizePairName(raw.to),
+    pairFrom: normalizePairName(raw.from),
+    minSz: minSz.toString(),
+    maxBSz: maxBSz.toString(),
+    maxSSz: maxSSz.toString(),
+    minNtl: MIN_NOTIONAL,
+    maxLeverage: pairMaxLeverage(raw),
+    overnightMaxLeverage: raw.overnightMaxLeverage ? formatLeverage(raw.overnightMaxLeverage) : 0,
+    rolloverFeePerBlock: formatTokens(raw.lastRolloverLongPure ?? "0").toString(),
+    openInterest: (buyOI_usd + sellOI_usd).toString(),
+    buyOpenInterest: buyOI_usd.toString(),
+    sellOpenInterest: sellOI_usd.toString(),
+    maxOpenInterest: maxOI_usd.toString(),
+    category: raw.group.name,
+    rolloverRate,
+    midPx: price ? price.mid.toString() : "0",
+    askPx: price ? price.ask.toString() : "0",
+    bidPx: price ? price.bid.toString() : "0",
+    isMarketOpen: price?.isMarketOpen ?? true,
+    isDayTradingClosed: price?.isDayTradingClosed ?? false,
+    secondsToToggleIsDayTradingClosed: price?.secondsToToggleIsDayTradingClosed ?? -1
+  };
+}
+function getRolloverRateDisplay(raw) {
+  const longPure = formatTokens(raw.lastRolloverLongPure ?? "0");
+  const premium = formatTokens(raw.brokerPremium ?? "0");
+  let contractLong = longPure + premium;
+  let contractShort = -longPure + premium;
+  if (!raw.isNegativeRolloverAllowed) {
+    contractLong = Math.max(contractLong, 0);
+    contractShort = Math.max(contractShort, 0);
+  }
+  const displayPerBlockLong = -contractLong;
+  const displayPerBlockShort = -contractShort;
+  const blocksInPeriod = ROLLOVER_RATE_HOURS * 60 * 60 * BLOCKS_PER_SECOND_ARBITRUM;
+  const periodMultiplier = blocksInPeriod * 100;
+  return {
+    long: (displayPerBlockLong * periodMultiplier).toString(),
+    short: (displayPerBlockShort * periodMultiplier).toString()
+  };
+}
+function formatPosition(raw, price, pnl, maxLeverage) {
+  const collateral = formatUsdc(raw.collateral);
+  const tradeNotional = formatTokens(raw.tradeNotional);
+  const leverage = formatLeverage(raw.leverage);
+  const mid = price?.mid ?? formatTokens(raw.pair.lastTradePrice);
+  const ntl = tradeNotional * mid;
+  const roe = collateral > 0 ? pnl.netPnl / collateral : 0;
+  return {
+    position: {
+      pairTo: normalizePairName(raw.pair.to),
+      pairFrom: normalizePairName(raw.pair.from),
+      pairId: String(raw.pair.id),
+      pid: raw.tradeID,
+      idx: parseInt(raw.index || "0") || 0,
+      side: raw.isBuy ? "B" : "S",
+      szi: tradeNotional.toString(),
+      entryPx: formatTokens(raw.openPrice).toString(),
+      leverage: leverage.toString(),
+      ntl: ntl.toString(),
+      unrealizedPnl: pnl.netPnl.toString(),
+      returnOnEquity: roe.toString(),
+      liquidationPx: pnl.liquidationPrice.toString(),
+      collateralUsed: collateral.toString(),
+      cumRollover: pnl.rollover.toString(),
+      ...raw.takeProfitPrice && raw.takeProfitPrice !== "0" ? { tpPx: formatTokens(raw.takeProfitPrice).toString() } : {},
+      ...raw.stopLossPrice && raw.stopLossPrice !== "0" ? { slPx: formatTokens(raw.stopLossPrice).toString() } : {},
+      openTimestamp: parseInt(raw.timestamp || "0") * 1e3,
+      isDayTrade: raw.isDayTrade ?? false,
+      maxLeverage: maxLeverage.toString()
+    },
+    maxWithdrawable: maxWithdrawForPosition(collateral, leverage, maxLeverage).toString()
+  };
+}
+function formatFill(raw) {
+  const collateral = formatUsdc(raw.collateral);
+  const tradeNotional = formatTokens(raw.tradeNotional);
+  const priceImpactP = formatTokens(raw.priceImpactP);
+  const devFee = formatUsdc(raw.devFee);
+  const vaultFee = formatUsdc(raw.vaultFee);
+  const oracleFee = formatUsdc(raw.oracleFee);
+  const rolloverFee = formatUsdc(raw.rolloverFee);
+  const liquidation = formatUsdc(raw.liquidationFee);
+  const builderFee = formatUsdc(raw.builderFee);
+  const totalProfitPercent = formatUsdc(raw.totalProfitPercent);
+  const action = raw.orderAction;
+  const type = raw.orderType;
+  const isClose = action === "Close" || action === "StopLoss" || action === "TakeProfit" || action === "CloseDayTrade";
+  const opening = action === "Open" ? (devFee + vaultFee).toString() : "0";
+  const rollover = isClose ? rolloverFee.toString() : "0";
+  const liquidationFee = action === "Liquidation" ? liquidation.toString() : "0";
+  const closedPnl = isClose || action === "Liquidation" ? (collateral * totalProfitPercent / 100 - devFee - vaultFee - oracleFee).toString() : "0";
+  const px = formatTokens(raw.priceAfterImpact);
+  const szi = tradeNotional;
+  const pxBeforeImpact = raw.isBuy ? px / (1 + priceImpactP / 100) : px / (1 - priceImpactP / 100);
+  const priceImpactFee = Math.abs((px - pxBeforeImpact) * szi);
+  return {
+    pairTo: normalizePairName(raw.pair.to),
+    pairFrom: normalizePairName(raw.pair.from),
+    pairId: String(raw.pair.id),
+    oid: raw.id,
+    pid: raw.tradeID,
+    side: raw.isBuy ? "B" : "S",
+    action,
+    type,
+    px: px.toString(),
+    szi: szi.toString(),
+    collateralUsed: collateral.toString(),
+    fees: {
+      opening,
+      rollover,
+      liquidation: liquidationFee,
+      builder: builderFee.toString(),
+      priceImpact: priceImpactFee.toString()
+    },
+    closedPnl,
+    hash: lowerHex(raw.executedTx) ?? "",
+    time: parseInt(raw.executedAt || "0") * 1e3
+  };
+}
+function formatOrder(raw) {
+  return {
+    ...formatFill(raw),
+    initiatedTx: lowerHex(raw.initiatedTx) ?? "",
+    initiatedTime: parseInt(raw.initiatedAt || "0") * 1e3,
+    isPending: raw.isPending,
+    isCancelled: raw.isCancelled,
+    ...raw.cancelReason ? { cancelReason: raw.cancelReason } : {}
+  };
+}
+function formatOpenOrder(raw) {
+  const tp = raw.takeProfitPrice && raw.takeProfitPrice !== "0" ? formatTokens(raw.takeProfitPrice) : null;
+  const sl = raw.stopLossPrice && raw.stopLossPrice !== "0" ? formatTokens(raw.stopLossPrice) : null;
+  const orderType = raw.limitType === "STOP" ? "Stop" : "Limit";
+  return {
+    pairTo: normalizePairName(raw.pair.to),
+    pairFrom: normalizePairName(raw.pair.from),
+    pairId: String(raw.pair.id),
+    idx: parseInt(raw.orderId || "0") || 0,
+    side: raw.isBuy ? "B" : "S",
+    limitPx: formatTokens(raw.openPrice).toString(),
+    szi: formatTokens(raw.tradeNotional).toString(),
+    ...tp !== null ? { tpPx: tp.toString() } : {},
+    ...sl !== null ? { slPx: sl.toString() } : {},
+    orderType,
+    timestamp: parseInt(raw.initiatedAt || "0") * 1e3
+  };
+}
+var EMPTY_RESULT = { long: [], short: [] };
+var ORDERBOOK_MAX_LEVELS = 20;
+function generateLogSpacedNotionals(levels, capacity) {
+  const n = Math.min(ORDERBOOK_MAX_LEVELS, Math.max(1, Math.floor(levels)));
+  if (capacity <= 0) return [];
+  if (n === 1) return [capacity];
+  const minNtl = Math.max(1, capacity / 3300);
+  if (minNtl >= capacity) return [capacity];
+  const logMin = Math.log(minNtl);
+  const logMax = Math.log(capacity);
+  return Array.from({ length: n }, (_, i) => {
+    if (i === n - 1) return capacity;
+    const t = i / (n - 1);
+    return Math.exp(logMin + t * (logMax - logMin));
+  });
+}
+function buildPairContext(raw, price) {
+  const maxOIUsd = formatUsdc(raw.maxOI);
+  const longOIUsd = formatTokens(raw.longOI) * price.mid;
+  const shortOIUsd = formatTokens(raw.shortOI) * price.mid;
+  return {
+    remLong: Math.max(0, maxOIUsd - longOIUsd),
+    remShort: Math.max(0, maxOIUsd - shortOIUsd),
+    midBN: parseTokens(price.mid).toString(),
+    askBN: parseTokens(price.ask).toString(),
+    bidBN: parseTokens(price.bid).toString(),
+    timeElapsed: timeElapsedSince(raw)
+  };
+}
+function priceImpactForLevel(raw, ctx, ntl, isBuy) {
+  return formulae.CalculateDynamicPriceImpact(
+    ctx.midBN,
+    ctx.askBN,
+    ctx.bidBN,
+    true,
+    // isOpen
+    isBuy,
+    parseUsdc2(ntl).toString(),
+    parseLeverage2(1).toString(),
+    raw.buyVolume ?? "0",
+    raw.sellVolume ?? "0",
+    raw.decayRate ?? "0",
+    ctx.timeElapsed,
+    raw.netVolThreshold ?? "0",
+    raw.priceImpactK ?? "0"
+  );
+}
+function simulateSlippageForPair(raw, ntls, price) {
+  if (!price || !price.mid) return EMPTY_RESULT;
+  const ctx = buildPairContext(raw, price);
+  const compute = (isBuy, capacity) => ntls.filter((ntl) => {
+    const n = Number(ntl);
+    return Number.isFinite(n) && n > 0 && n <= capacity;
+  }).map((ntl) => {
+    const result = priceImpactForLevel(raw, ctx, Number(ntl), isBuy);
+    return { ntl, slippage: formatTokens(result.priceImpactP).toString() };
+  });
+  return {
+    long: compute(true, ctx.remLong),
+    short: compute(false, ctx.remShort)
+  };
+}
+function simulateOrderbookForPair(raw, price, levels) {
+  const safeLevels = Math.min(ORDERBOOK_MAX_LEVELS, Math.max(1, Math.floor(levels)));
+  const ctx = buildPairContext(raw, price);
+  const askNtls = generateLogSpacedNotionals(safeLevels, ctx.remLong);
+  const bidNtls = generateLogSpacedNotionals(safeLevels, ctx.remShort);
+  const toLevel = (ntl, isBuy) => {
+    const result = priceImpactForLevel(raw, ctx, ntl, isBuy);
+    const px = formatTokens(result.priceAfterImpact);
+    return {
+      px: px.toString(),
+      sz: (px > 0 ? ntl / px : 0).toString(),
+      n: 1
+    };
+  };
+  return {
+    pairId: String(raw.id),
+    pairFrom: normalizePairName(raw.from),
+    pairTo: normalizePairName(raw.to),
+    levels: [
+      bidNtls.map((n) => toLevel(n, false)),
+      // bids: short entries, best (closest to mid) first
+      askNtls.map((n) => toLevel(n, true))
+      // asks: long entries, best (closest to mid) first
+    ],
+    time: Date.now()
+  };
+}
+
+// src/data/client.ts
+var OstiumSubgraphClient = class _OstiumSubgraphClient {
+  gql;
+  builderApiUrl;
+  /** Cached pair-name (`${from}/${to}`) → `pairId` map. Refreshed lazily. */
+  pairIdCache = null;
+  /** Cached `pairId` → `"FROM-TO"` in raw subgraph dash format (used for OHLC API). */
+  pairRawNameCache = null;
+  constructor(gql, builderApiUrl) {
+    this.gql = gql;
+    this.builderApiUrl = builderApiUrl;
+  }
+  /**
+   * Create a client connected to the Ostium subgraph.
+   *
+   * Fetches the full pair list at startup so that `streamPrices`, `getCandles`,
+   * and `getAllPrices` can resolve pair ids to raw names without an extra round-trip.
+   *
+   * ```ts
+   * // Mainnet (default)
+   * const client = await OstiumSubgraphClient.create();
+   *
+   * // Testnet (Arbitrum Sepolia)
+   * const client = await OstiumSubgraphClient.create({ testnet: true });
+   * ```
+   */
+  static async create(config = {}) {
+    const endpoint = config.endpoint ?? (config.testnet ? DEFAULT_SUBGRAPH_ENDPOINT_TESTNET : DEFAULT_SUBGRAPH_ENDPOINT);
+    if (!endpoint.startsWith("http")) {
+      throw new OstiumSubgraphError(
+        `Invalid subgraph endpoint: ${endpoint}`,
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    const client = new _OstiumSubgraphClient(
+      new graphqlRequest.GraphQLClient(endpoint),
+      config.builderApiUrl ?? DEFAULT_BUILDER_API_URL
+    );
+    await client.initPairCache();
+    return client;
+  }
+  async initPairCache() {
+    const rawPairs = await this.fetchRawPairs();
+    this.refreshPairIdCache(rawPairs);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Pairs
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * All trading pairs with computed `minSz`/`maxBSz`/`maxSSz`, live prices, and
+   * market-status flags. Pass `pairIds` to restrict to a subset.
+   */
+  async getPairs(params) {
+    const [rawPairs, prices] = await Promise.all([
+      this.fetchRawPairs(),
+      this.fetchLivePricesSafe()
+    ]);
+    this.refreshPairIdCache(rawPairs);
+    let filtered = rawPairs;
+    if (params?.pairIds && params.pairIds.length > 0) {
+      const requested = new Set(params.pairIds.map(String));
+      filtered = rawPairs.filter((p) => requested.has(String(p.id)));
+    }
+    return { pairs: filtered.map((p) => formatPair(p, prices[`${p.from}/${p.to}`])) };
+  }
+  /** Live mid/bid/ask prices keyed by `pairId`. */
+  async getAllPrices() {
+    const [pairIdMap, prices] = await Promise.all([
+      this.ensurePairIdCache(),
+      this.fetchLivePricesSafe()
+    ]);
+    const out = {};
+    for (const [name, price] of Object.entries(prices)) {
+      const id = pairIdMap.get(name);
+      if (!id) continue;
+      out[id] = {
+        ask: price.ask.toString(),
+        bid: price.bid.toString(),
+        mid: price.mid.toString()
+      };
+    }
+    return { prices: out };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Open positions
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Open positions for a trader, sorted newest first, with margin summary.
+   *
+   * - Fetches live prices automatically.
+   * - `blockNumber` is required for live PnL (rollover projection). When omitted,
+   *   PnL fields are zeroed.
+   */
+  async getOpenPositions(params) {
+    const { user, blockNumber } = params;
+    const [trades, prices] = await Promise.all([
+      paginateAll(async (skip, first) => {
+        const data = await this.query(
+          GetTraderOpenTradesQuery,
+          { trader: user.toLowerCase(), skip, first }
+        );
+        return data.trades;
+      }),
+      this.fetchLivePricesSafe()
+    ]);
+    let totalWithdrawable = 0;
+    const pairPositions = trades.map((trade) => {
+      const price = prices[`${trade.pair.from}/${trade.pair.to}`];
+      const pnl = price && blockNumber ? getTradePnL(trade, price, blockNumber) : EMPTY_PNL;
+      const maxLev = trade.isDayTrade ? formatLeverage(trade.pair.overnightMaxLeverage) : pairMaxLeverage(trade.pair);
+      const pairPos = formatPosition(trade, price, pnl, maxLev);
+      totalWithdrawable += parseFloat(pairPos.maxWithdrawable);
+      return pairPos;
+    });
+    const marginSummary = aggregateMarginSummary(pairPositions);
+    return {
+      pairPositions,
+      marginSummary,
+      withdrawable: totalWithdrawable.toString(),
+      time: Date.now()
+    };
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Fills
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Executed fills, sorted by `executedAt desc`.
+   *
+   * - `user`: pass an address to scope to a single trader, or `'ALL'` to fetch
+   *   fills across every trader (no trader filter).
+   * - `pairId`: optional pair filter — when set, only fills on this pair are returned.
+   */
+  async getFills(params) {
+    return this.fetchFills(params, void 0);
+  }
+  /** Executed fills within an inclusive time range (Unix ms). Same filters as `getFills`. */
+  async getFillsByTime(params) {
+    const endTime = params.endTime ?? Date.now();
+    return this.fetchFills(params, {
+      startSec: Math.floor(params.startTime / 1e3).toString(),
+      endSec: Math.floor(endTime / 1e3).toString()
+    });
+  }
+  async fetchFills(filters, timeRange) {
+    const hasTrader = filters.user !== "ALL";
+    const hasPairId = filters.pairId !== void 0;
+    const limit = filters.limit ?? 1e3;
+    const document = buildExecutedFillsQuery({
+      hasTrader,
+      hasPairId,
+      hasTimeRange: timeRange !== void 0
+    });
+    const orders = await paginateAll(
+      async (skip, first) => {
+        const variables = { skip, first };
+        if (hasTrader) variables.trader = filters.user.toLowerCase();
+        if (hasPairId) variables.pairId = String(filters.pairId);
+        if (timeRange) {
+          variables.startSec = timeRange.startSec;
+          variables.endSec = timeRange.endSec;
+        }
+        const data = await this.query(document, variables);
+        return data.orders;
+      },
+      1e3,
+      limit
+    );
+    return orders.map(formatFill);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Open limit orders
+  // ─────────────────────────────────────────────────────────────────────────
+  /** Active limit orders for a trader, sorted by `updatedAt desc`. */
+  async getOpenOrders({ user }) {
+    const limits = await paginateAll(async (skip, first) => {
+      const data = await this.query(
+        GetTraderActiveLimitsQuery,
+        { trader: user.toLowerCase(), skip, first }
+      );
+      return data.limits;
+    });
+    return limits.map(formatOpenOrder);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Orders (any status)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch orders at any status — pending, executed, or cancelled.
+   *
+   * - Pass `initiatedTxHashes` (e.g. `[result.txHash]` from `openTrade` / `closeTrade`)
+   *   to poll by the subgraph `initiatedTx` field.
+   * - Pass `orderIds` to look up by on-chain order id (mutually exclusive with
+   *   `initiatedTxHashes`).
+   * - Pass only `user` (or omit on `OstiumClient`) to get recent orders for
+   *   a trader regardless of status.
+   */
+  async getOrders(params = {}) {
+    const hasOrderIds = !!(params.orderIds && params.orderIds.length > 0);
+    const hasInitiatedTxHashes = !!(params.initiatedTxHashes && params.initiatedTxHashes.length > 0);
+    if (hasOrderIds && hasInitiatedTxHashes) {
+      throw new OstiumSubgraphError(
+        "getOrders: pass either orderIds or initiatedTxHashes, not both",
+        "INVALID_PARAMS" /* INVALID_PARAMS */
+      );
+    }
+    const hasTrader = !hasOrderIds && !hasInitiatedTxHashes && !!params.user;
+    const limit = params.limit ?? 100;
+    const document = buildGetOrdersQuery({
+      hasOrderIds,
+      hasInitiatedTxHashes,
+      hasTrader
+    });
+    const orders = await paginateAll(
+      async (skip, first) => {
+        const variables = { skip, first };
+        if (hasOrderIds) variables.ids = params.orderIds.map(String);
+        if (hasInitiatedTxHashes) {
+          variables.txHashes = params.initiatedTxHashes.map(
+            (h) => typeof h === "string" ? h.toLowerCase() : h
+          );
+        }
+        if (hasTrader) variables.trader = params.user.toLowerCase();
+        const data = await this.query(document, variables);
+        return data.orders;
+      },
+      100,
+      limit
+    );
+    return orders.map(formatOrder);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Simulated slippage
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Simulate the dynamic-spread slippage a long and a short entry of each
+   * notional would experience on the given pairs. Notionals exceeding the
+   * side's remaining open-interest capacity (`maxOI − sideOI`) are dropped.
+   *
+   * Computed via `CalculateDynamicPriceImpact` from `@ostium/formulae` using
+   * the pair's live OI / decay / threshold params + the current bid/mid/ask
+   * from the live-prices feed (collateral = `ntl`, leverage = 1).
+   *
+   * ```ts
+   * const sim = await client.getSimSlippage({
+   *   pairIds: ['0', '1'],
+   *   ntls:    ['10000', '100000', '1000000'],
+   * });
+   * // → { '0': { long: [{ ntl, slippage }...], short: [...] }, '1': ... }
+   * ```
+   */
+  async getSimSlippage(params) {
+    const [rawPairs, prices] = await Promise.all([
+      this.fetchRawPairs(),
+      this.fetchLivePricesSafe()
+    ]);
+    this.refreshPairIdCache(rawPairs);
+    const requested = new Set(params.pairIds.map(String));
+    const out = {};
+    for (const pair of rawPairs) {
+      const id = String(pair.id);
+      if (!requested.has(id)) continue;
+      const price = prices[`${pair.from}/${pair.to}`];
+      out[id] = simulateSlippageForPair(pair, params.ntls, price);
+    }
+    return out;
+  }
+  /**
+   * Build a synthetic bid/ask orderbook for a single pair using the on-chain
+   * dynamic-spread params. Each side gets up to `levels` (capped at 20)
+   * exponentially-spaced notional levels (`[1, 2, 3, 5] × 10ⁿ`), stopping at
+   * the side's remaining open-interest capacity.
+   *
+   * ```ts
+   * const ob = await client.getSimOrderbook({ pairId: '0', levels: 20 });
+   * // ob.asks: long-entry levels (you'd buy at `px`)
+   * // ob.bids: short-entry levels (you'd sell at `px`)
+   * ```
+   */
+  async getSimOrderbook(params) {
+    const targetId = String(params.pairId);
+    const levels = params.levels ?? 20;
+    const [rawPairs, prices] = await Promise.all([
+      this.fetchRawPairs(),
+      this.fetchLivePricesSafe()
+    ]);
+    this.refreshPairIdCache(rawPairs);
+    const pair = rawPairs.find((p) => String(p.id) === targetId);
+    if (!pair) {
+      throw new OstiumSubgraphError(
+        `Pair ${targetId} not found in subgraph response`,
+        "NOT_FOUND" /* NOT_FOUND */
+      );
+    }
+    const price = prices[`${pair.from}/${pair.to}`];
+    if (!price || !price.mid) {
+      throw new OstiumSubgraphError(
+        `No live price available for ${pair.from}/${pair.to}`,
+        "NOT_FOUND" /* NOT_FOUND */
+      );
+    }
+    return simulateOrderbookForPair(pair, price, levels);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // OHLC candles
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Fetch OHLC candles for a pair.
+   *
+   * `pairId` maps to the raw subgraph pair name internally (e.g. pair `0` →
+   * `"BTC-USD"`). `from` / `to` are Unix milliseconds; `resolution` is one of
+   * `"1"`, `"5"`, `"15"`, `"60"`, `"240"`, `"1D"`.
+   *
+   * ```ts
+   * const candles = await client.getCandles({
+   *   pairId: 0,
+   *   from: Date.now() - 7 * 86_400_000,
+   *   resolution: '1D',
+   * });
+   * ```
+   */
+  async getCandles(params) {
+    const rawPair = await this.ensurePairRawName(params.pairId);
+    return fetchCandles(
+      this.builderApiUrl,
+      rawPair,
+      params.from,
+      params.to ?? Date.now(),
+      params.resolution
+    );
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Live price stream (WebSocket)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Open a WebSocket connection to the live price stream.
+   *
+   * Optionally filter to a subset of pairs by `pairId` — same values as returned by
+   * `getPairs()`. When provided, the client sends `{ type: "subscribe", pairs }` on
+   * `open` (no `?pairs=` query on the URL). Omit `pairIds` to receive the full feed.
+   *
+   * The returned `OstiumPriceStream` fires an initial `snapshot` event with all
+   * cached ticks, then a `tick` event on every update. `PriceTick.from` / `.to`
+   * are normalized display names (e.g. `"WTI"` not `"CL"`).
+   *
+   * ```ts
+   * const stream = client.streamPrices([0, 1]);  // BTC and ETH by pairId
+   *
+   * stream.onOpen(() => console.log('connected'));
+   * stream.onSnapshot(ticks => console.log('snapshot', ticks.length));
+   * stream.onTick(tick => console.log(tick.pair, tick.mid));
+   *
+   * // Dynamically add / remove by pairId:
+   * stream.subscribe([2]);
+   * stream.unsubscribe([0]);
+   * stream.close();
+   * ```
+   *
+   * Requires a runtime with native `WebSocket` (Node.js 18+, Bun, browsers). Bun’s
+   * `WebSocket` may fail some `https://` upgrades (e.g. CloudFront); use Node if so.
+   */
+  streamPrices(pairIds) {
+    const cache = this.pairRawNameCache ?? /* @__PURE__ */ new Map();
+    const rawNames = pairIds?.map((id) => {
+      const name = cache.get(String(id));
+      if (!name) throw new OstiumSubgraphError(`Pair ${id} not found`, "NOT_FOUND" /* NOT_FOUND */);
+      return name;
+    });
+    return OstiumPriceStream.connect(this.builderApiUrl, rawNames, cache);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Internal — fetchers, cache, query wrapper
+  // ─────────────────────────────────────────────────────────────────────────
+  async fetchRawPairs() {
+    const data = await this.query(GetPairsAndGroupsQuery);
+    return data.pairs;
+  }
+  refreshPairIdCache(rawPairs) {
+    this.pairIdCache = new Map(rawPairs.map((p) => [`${p.from}/${p.to}`, String(p.id)]));
+    this.pairRawNameCache = new Map(rawPairs.map((p) => [String(p.id), `${p.from}-${p.to}`]));
+  }
+  async ensurePairIdCache() {
+    if (this.pairIdCache) return this.pairIdCache;
+    this.refreshPairIdCache(await this.fetchRawPairs());
+    return this.pairIdCache;
+  }
+  async ensurePairRawName(pairId) {
+    if (!this.pairRawNameCache) {
+      this.refreshPairIdCache(await this.fetchRawPairs());
+    }
+    const name = this.pairRawNameCache.get(String(pairId));
+    if (!name) {
+      throw new OstiumSubgraphError(
+        `Pair ${pairId} not found`,
+        "NOT_FOUND" /* NOT_FOUND */
+      );
+    }
+    return name;
+  }
+  /** Wrapped `fetchLivePrices` that swallows network errors and returns `{}`. */
+  async fetchLivePricesSafe() {
+    try {
+      return await fetchLivePrices(this.builderApiUrl);
+    } catch {
+      return {};
+    }
+  }
+  async query(document, variables) {
+    try {
+      return await this.gql.request(document, variables);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const lower = msg.toLowerCase();
+      if (lower.includes("network") || lower.includes("timeout") || lower.includes("fetch")) {
+        throw new OstiumSubgraphError(
+          `Subgraph network error: ${msg}`,
+          "FETCH_FAILED" /* FETCH_FAILED */,
+          err
+        );
+      }
+      throw new OstiumSubgraphError(
+        `Subgraph query failed: ${msg}`,
+        "FETCH_FAILED" /* FETCH_FAILED */,
+        err
+      );
+    }
+  }
+};
+function aggregateMarginSummary(pairPositions) {
+  let accountValue = 0;
+  let totalCollateralUsed = 0;
+  let totalNtlPos = 0;
+  let totalRawPnlUsd = 0;
+  for (const { position } of pairPositions) {
+    const collateral = parseFloat(position.collateralUsed) || 0;
+    const ntl = parseFloat(position.ntl) || 0;
+    const pnl = parseFloat(position.unrealizedPnl) || 0;
+    accountValue += collateral + pnl;
+    totalCollateralUsed += collateral;
+    totalNtlPos += ntl;
+    totalRawPnlUsd += pnl;
+  }
+  return {
+    accountValue: accountValue.toString(),
+    totalCollateralUsed: totalCollateralUsed.toString(),
+    totalNtlPos: totalNtlPos.toString(),
+    totalRawPnlUsd: totalRawPnlUsd.toString()
+  };
+}
+
+// src/client.ts
+var HEX64_RE = /^0x[0-9a-fA-F]{64}$/;
+var ADDRESS_RE = /^0x[0-9a-fA-F]{40}$/;
+function validateConfig(config) {
+  if (!HEX64_RE.test(config.privateKey)) {
+    throw new OstiumError(
+      "privateKey must be a 64-character hex string prefixed with 0x",
+      "INVALID_CONFIG" /* INVALID_CONFIG */
+    );
+  }
+  if (config.traderAddress && !ADDRESS_RE.test(config.traderAddress)) {
+    throw new OstiumError(
+      "traderAddress must be a valid 42-character Ethereum address (0x + 40 hex chars)",
+      "INVALID_CONFIG" /* INVALID_CONFIG */
+    );
+  }
+  if (config.slippageBps !== void 0 && (config.slippageBps < 0 || config.slippageBps > 500)) {
+    throw new OstiumError(
+      "slippageBps must be between 0 and 500 (0%\u20135%)",
+      "INVALID_CONFIG" /* INVALID_CONFIG */
+    );
+  }
+  if (config.builder !== void 0 && (config.builder.feeBps < 0 || config.builder.feeBps > 50)) {
+    throw new OstiumError(
+      "builder.feeBps must be between 0 and 50 (max 0.5%)",
+      "INVALID_CONFIG" /* INVALID_CONFIG */
+    );
+  }
+}
+var OstiumClient = class _OstiumClient {
+  signer;
+  submitter;
+  contracts;
+  publicClient;
+  defaultSlippageBps;
+  delegated;
+  gasless;
+  selfGasless;
+  eoaSubmit;
+  builderAddress;
+  builderFeeBps;
+  /** Internal subgraph client backing all read methods (`getPairs`, `getOpenPositions`, …). */
+  subgraph;
+  constructor(internals) {
+    this.signer = internals.signer;
+    this.submitter = internals.submitter;
+    this.contracts = internals.contracts;
+    this.publicClient = internals.publicClient;
+    this.defaultSlippageBps = internals.defaultSlippageBps;
+    this.delegated = internals.delegated;
+    this.gasless = internals.gasless;
+    this.selfGasless = internals.selfGasless;
+    this.eoaSubmit = internals.eoaSubmit;
+    this.builderAddress = internals.builderAddress;
+    this.builderFeeBps = internals.builderFeeBps;
+    this.subgraph = internals.subgraph;
+  }
+  /**
+   * **Self + Self** — your EOA signs every transaction and pays gas directly.
+   *
+   * Use this when you want the simplest possible setup: one key, no smart accounts,
+   * no delegation. Your EOA holds USDC and owns all positions.
+   *
+   * ```ts
+   * const client = await OstiumClient.createSelfAndSelf({
+   *   traderPrivateKey: '0x...',
+   *   rpcUrl: 'https://arb-mainnet.g.alchemy.com/v2/...',
+   * });
+   * await client.openTrade({ ... });
+   * ```
+   */
+  static async createSelfAndSelf(params) {
+    return _OstiumClient._fromConfig({
+      privateKey: params.traderPrivateKey,
+      rpcUrl: params.rpcUrl,
+      testnet: params.testnet,
+      slippageBps: params.slippageBps,
+      builder: params.builder,
+      subgraphUrl: params.subgraphUrl,
+      builderApiUrl: params.builderApiUrl
+    });
+  }
+  /**
+   * **Self + Gasless** — your EOA owns everything; a Safe relays trades for free.
+   *
+   * Your EOA holds USDC and owns all positions. A Safe smart account is derived
+   * deterministically from your private key and registered as your on-chain delegate.
+   * After a one-time setup (approve USDC + `setupGaslessDelegation()`), all trades
+   * are submitted as sponsored UserOperations — no ETH required.
+   *
+   * ```ts
+   * const client = await OstiumClient.createSelfAndGasless({
+   *   traderPrivateKey: '0x...',
+   *   pimlicoUrl: 'https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161',
+   * });
+   * // One-time setup — EOA pays gas once for each:
+   * await client.approveUsdc('max');
+   * await client.setupGaslessDelegation();
+   * // All subsequent trading is gasless:
+   * await client.openTrade({ ... });
+   * ```
+   */
+  static async createSelfAndGasless(params) {
+    const defaultUrl = params.testnet ? DEFAULT_PIMLICO_URL_TESTNET : DEFAULT_PIMLICO_URL;
+    return _OstiumClient._fromConfig({
+      privateKey: params.traderPrivateKey,
+      pimlicoUrl: params.pimlicoUrl ?? defaultUrl,
+      rpcUrl: params.rpcUrl,
+      sponsorshipPolicyId: params.sponsorshipPolicyId,
+      testnet: params.testnet,
+      slippageBps: params.slippageBps,
+      builder: params.builder,
+      subgraphUrl: params.subgraphUrl,
+      builderApiUrl: params.builderApiUrl
+    });
+  }
+  /**
+   * **Delegated + Self** — a delegate EOA signs and pays gas on behalf of a trader address.
+   *
+   * The trader retains custody of USDC and positions. The delegate only needs ETH
+   * for gas. Every trade is wrapped in `delegatedAction(traderAddress, callData)`.
+   * The trader must call `setDelegate(delegateAddress)` once before this client
+   * can submit trades.
+   *
+   * ```ts
+   * const client = await OstiumClient.createDelegatedAndSelf({
+   *   delegatePrivateKey: '0xDelegateKey',
+   *   traderAddress: '0xTraderAddress',
+   *   rpcUrl: 'https://arb-mainnet.g.alchemy.com/v2/...',
+   * });
+   * await client.openTrade({ ... });
+   * ```
+   */
+  static async createDelegatedAndSelf(params) {
+    return _OstiumClient._fromConfig({
+      privateKey: params.delegatePrivateKey,
+      traderAddress: params.traderAddress,
+      rpcUrl: params.rpcUrl,
+      testnet: params.testnet,
+      slippageBps: params.slippageBps,
+      builder: params.builder,
+      subgraphUrl: params.subgraphUrl,
+      builderApiUrl: params.builderApiUrl
+    });
+  }
+  /**
+   * **Delegated + Gasless** — a Safe derived from the delegate key submits sponsored
+   * UserOperations on behalf of the trader. No ETH needed after setup.
+   *
+   * The trader retains custody of USDC and positions. The delegate's Safe submits
+   * trades as UserOperations via Pimlico. The trader must call `setDelegate(safeAddress)`
+   * once — use `client.getSmartAccountAddress()` to retrieve the Safe address.
+   *
+   * ```ts
+   * const client = await OstiumClient.createDelegatedAndGasless({
+   *   delegatePrivateKey: '0xDelegateKey',
+   *   traderAddress: '0xTraderAddress',
+   *   pimlicoUrl: 'https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161',
+   * });
+   * await client.openTrade({ ... }); // gasless delegatedAction UserOp
+   * ```
+   */
+  static async createDelegatedAndGasless(params) {
+    const defaultUrl = params.testnet ? DEFAULT_PIMLICO_URL_TESTNET : DEFAULT_PIMLICO_URL;
+    return _OstiumClient._fromConfig({
+      privateKey: params.delegatePrivateKey,
+      traderAddress: params.traderAddress,
+      pimlicoUrl: params.pimlicoUrl ?? defaultUrl,
+      rpcUrl: params.rpcUrl,
+      sponsorshipPolicyId: params.sponsorshipPolicyId,
+      testnet: params.testnet,
+      slippageBps: params.slippageBps,
+      builder: params.builder,
+      subgraphUrl: params.subgraphUrl,
+      builderApiUrl: params.builderApiUrl
+    });
+  }
+  /**
+   * **Read-only client** — no signer, no submitter, no privateKey required.
+   *
+   * All read methods (`getPairs`, `getOpenPositions`, `getFills`, `getBalances`, …)
+   * are available. Methods that take an optional `user` argument require it to be
+   * passed explicitly. Calling any write method throws `INVALID_CONFIG`.
+   *
+   * ```ts
+   * const reader = await OstiumClient.createReadOnly();
+   * const { pairs } = await reader.getPairs();
+   * const balances = await reader.getBalances('0xTrader...');
+   * const positions = await reader.getOpenPositions({ user: '0xTrader...' });
+   * ```
+   */
+  static async createReadOnly(params = {}) {
+    const testnet = params.testnet ?? false;
+    const networkConfig = getNetworkConfig(testnet);
+    const chain = testnet ? chains.arbitrumSepolia : chains.arbitrum;
+    const rpcUrl = params.rpcUrl ?? chain.rpcUrls.default.http[0];
+    const contracts = {
+      trading: networkConfig.contracts.trading,
+      tradingStorage: networkConfig.contracts.tradingStorage,
+      usdc: networkConfig.contracts.usdc
+    };
+    const publicClient = viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+    const subgraph = await OstiumSubgraphClient.create({
+      testnet,
+      endpoint: params.subgraphUrl,
+      builderApiUrl: params.builderApiUrl
+    });
+    return new _OstiumClient({
+      contracts,
+      publicClient,
+      defaultSlippageBps: Math.round(DEFAULT_SLIPPAGE_PERCENTAGE * 100),
+      delegated: false,
+      gasless: false,
+      selfGasless: false,
+      subgraph
+    });
+  }
+  /** Internal factory shared by all public constructors. */
+  static async _fromConfig(config) {
+    validateConfig(config);
+    const testnet = config.testnet ?? false;
+    const networkConfig = getNetworkConfig(testnet);
+    const chain = testnet ? chains.arbitrumSepolia : chains.arbitrum;
+    const defaultSlippageBps = config.slippageBps ?? Math.round(DEFAULT_SLIPPAGE_PERCENTAGE * 100);
+    const contracts = {
+      trading: networkConfig.contracts.trading,
+      tradingStorage: networkConfig.contracts.tradingStorage,
+      usdc: networkConfig.contracts.usdc
+    };
+    const selfGasless = isGasless(config) && !isDelegated(config);
+    const submitter = await createSubmitter(config, testnet);
+    let traderAddress;
+    if (isDelegated(config)) {
+      traderAddress = config.traderAddress;
+    } else {
+      traderAddress = accounts.privateKeyToAccount(config.privateKey).address;
+    }
+    const signer = createSigner(config, traderAddress, selfGasless);
+    const publicRpc = testnet ? "https://sepolia-rollup.arbitrum.io/rpc" : "https://arb1.arbitrum.io/rpc";
+    const rpcUrl = config.rpcUrl ?? (isGasless(config) ? publicRpc : void 0);
+    if (!isGasless(config) && !config.rpcUrl) {
+      throw new OstiumError(
+        "rpcUrl is required for self-submission mode",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    const publicClient = viem.createPublicClient({ chain, transport: viem.http(rpcUrl) });
+    let eoaSubmit;
+    if (selfGasless) {
+      const eoaAccount = accounts.privateKeyToAccount(config.privateKey);
+      const eoaRpcUrl = config.rpcUrl ?? publicRpc;
+      const eoaWalletClient = viem.createWalletClient({ account: eoaAccount, chain, transport: viem.http(eoaRpcUrl) });
+      eoaSubmit = async (encoded) => {
+        const txHash = await eoaWalletClient.sendTransaction({
+          account: eoaAccount,
+          to: encoded.to,
+          data: encoded.data,
+          value: encoded.value
+        });
+        return { txHash };
+      };
+    }
+    const subgraph = await OstiumSubgraphClient.create({
+      testnet,
+      endpoint: config.subgraphUrl,
+      builderApiUrl: config.builderApiUrl
+    });
+    return new _OstiumClient({
+      signer,
+      submitter,
+      contracts,
+      publicClient,
+      defaultSlippageBps,
+      delegated: isDelegated(config),
+      gasless: isGasless(config),
+      selfGasless,
+      eoaSubmit,
+      builderAddress: config.builder?.address,
+      builderFeeBps: config.builder?.feeBps,
+      subgraph
+    });
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Getters
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * The on-chain address that owns trades and USDC allowances.
+   *
+   * - Self + Self / Delegated modes: trader's EOA or configured traderAddress.
+   * - Self + Gasless: EOA derived from privateKey (NOT the Safe — USDC lives here).
+   */
+  getTraderAddress() {
+    if (!this.signer) {
+      throw new OstiumError(
+        "No connected trader \u2014 pass `user` explicitly or use one of the createSelfAnd*/createDelegatedAnd* factories.",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    return this.signer.traderAddress;
+  }
+  /** True when the client was created via `createReadOnly` and cannot submit transactions. */
+  isReadOnly() {
+    return !this.signer || !this.submitter;
+  }
+  /**
+   * Returns the Safe smart-account address used for gasless submission.
+   * Returns undefined when not in gasless mode.
+   *
+   * - Self + Gasless:      Safe that submits on behalf of the EOA (the delegate).
+   *                        Pass this address to setupGaslessDelegation().
+   * - Delegated + Gasless: delegate's Safe address.
+   * - Self + Self / Delegated + Self: returns undefined.
+   */
+  getSmartAccountAddress() {
+    return this.gasless && this.submitter ? this.submitter.effectiveSender : void 0;
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Self + Gasless setup
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * One-time setup for Self + Gasless mode.
+   *
+   * Registers the Safe smart account as a delegate on the trading contract so
+   * the Safe can submit gasless trades on behalf of your EOA. The EOA pays gas
+   * for this single transaction; all subsequent trading is gasless.
+   *
+   * Only callable in Self + Gasless mode. Throws INVALID_CONFIG otherwise.
+   *
+   * @example
+   * ```ts
+   * const client = await OstiumClient.create({ privateKey: '0x...', pimlicoUrl: 'https://builder.ostium.io/v1/pimlico/sponsor?chainId=42161' });
+   * await client.approveUsdc('max');         // EOA approves USDC (gas, one-time)
+   * await client.setupGaslessDelegation();   // EOA sets Safe as delegate (gas, one-time)
+   * // From here: all trading is gasless
+   * await client.openTrade({ ... });
+   * ```
+   */
+  async setupGaslessDelegation() {
+    if (!this.selfGasless || !this.eoaSubmit || !this.submitter) {
+      throw new OstiumError(
+        "setupGaslessDelegation() is only available in Self + Gasless mode. Create the client with pimlicoUrl but without traderAddress.",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    const safeAddress = this.submitter.effectiveSender;
+    const encoded = encodeSetDelegate(safeAddress, this.contracts.trading);
+    return this.submitDirectFromEoa(encoded);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // USDC helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Check whether the trader's USDC allowance covers the required amount.
+   * The allowance is always checked against signer.traderAddress (the EOA in
+   * Self + Gasless mode, the Safe in Delegated + Gasless).
+   */
+  async checkUsdcAllowance(requiredUsd) {
+    const required = parseUsdc(requiredUsd);
+    const current = await this.publicClient.readContract({
+      address: this.contracts.usdc,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [this.getTraderAddress(), this.contracts.tradingStorage]
+    });
+    return { current, required, sufficient: current >= required };
+  }
+  /**
+   * USDC and ETH balances plus the USDC allowance to TradingStorage.
+   * All three values are decimal strings so large values (e.g. max USDC approval)
+   * are preserved exactly. Parse with `parseFloat` / `Number` only for display.
+   *
+   * In read-only mode, pass `user` explicitly. With a connected trader, omit it
+   * to read the connected address.
+   */
+  async getBalances(user) {
+    const trader = user ?? this.getTraderAddress();
+    const [usdcRaw, ethRaw, allowanceRaw] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.contracts.usdc,
+        abi: ERC20_ABI,
+        functionName: "balanceOf",
+        args: [trader]
+      }),
+      this.publicClient.getBalance({ address: trader }),
+      this.publicClient.readContract({
+        address: this.contracts.usdc,
+        abi: ERC20_ABI,
+        functionName: "allowance",
+        args: [trader, this.contracts.tradingStorage]
+      })
+    ]);
+    return {
+      usdc: viem.formatUnits(usdcRaw, 6),
+      eth: viem.formatUnits(ethRaw, 18),
+      allowance: viem.formatUnits(allowanceRaw, 6)
+    };
+  }
+  /**
+   * Approve USDC spending by the TradingStorage contract.
+   *
+   * - Self + Self: submitted gaslessly from EOA.
+   * - Self + Gasless: submitted directly from EOA (the delegate cannot approve
+   *   on behalf of the trader). The EOA pays gas for this one-time operation.
+   * - Delegated modes: throws — the trader must approve from their own account.
+   *
+   * @param amount USD amount as decimal string (e.g. "1000"), or "max" for MaxUint256.
+   */
+  async approveUsdc(amount) {
+    if (this.delegated) {
+      throw new OstiumError(
+        "approveUsdc is not available in delegated mode. The trader must approve USDC directly from their own account.",
+        "DELEGATION_FAILED" /* DELEGATION_FAILED */
+      );
+    }
+    const rawAmount = amount === "max" ? viem.maxUint256 : parseUsdc(amount);
+    const encoded = encodeUsdcApprove(this.contracts.tradingStorage, rawAmount, this.contracts.usdc);
+    if (this.selfGasless) {
+      return this.submitDirectFromEoa(encoded);
+    }
+    return this.requireWriter().submitter.submit(encoded);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Delegation helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Set a delegate on the trading contract.
+   *
+   * - Self + Self: EOA directly registers a delegate.
+   * - Self + Gasless: NOT recommended — use setupGaslessDelegation() instead.
+   * - Delegated modes: wrapped in delegatedAction so the existing delegate can
+   *   update the trader's delegation on their behalf.
+   */
+  async setDelegate(delegateAddress) {
+    const encoded = encodeSetDelegate(delegateAddress, this.contracts.trading);
+    return this.execute(encoded);
+  }
+  /**
+   * Remove the current delegate on the trading contract.
+   * Follows the same delegation-wrapping rules as setDelegate().
+   */
+  async removeDelegate() {
+    const encoded = encodeRemoveDelegate(this.contracts.trading);
+    return this.execute(encoded);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Core trading methods
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Open a new trade position.
+   *
+   * Call `approveUsdc()` (once) before the first trade — the contract will revert
+   * on-chain if the USDC allowance is insufficient. Use `getBalances()` to check
+   * the current allowance.
+   */
+  async openTrade(params) {
+    const collateralNum = parseFloat(params.collateral);
+    if (collateralNum > MAX_COLLATERAL_USD) {
+      throw new OstiumError(
+        `Collateral ${params.collateral} exceeds maximum ${MAX_COLLATERAL_USD}`,
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */
+      );
+    }
+    const apiOpen = {
+      a: params.pairIndex,
+      b: params.buy,
+      p: params.price,
+      s: params.collateral,
+      l: params.leverage,
+      t: params.type,
+      tp: params.takeProfit,
+      sl: params.stopLoss,
+      d: params.isDayTrade
+    };
+    const apiBuilder = this.builderAddress !== void 0 && this.builderFeeBps !== void 0 ? { b: this.builderAddress, f: this.builderFeeBps } : void 0;
+    let trade, orderType;
+    try {
+      ({ trade, orderType } = buildTrade(apiOpen, this.getTraderAddress()));
+    } catch (err) {
+      throw new OstiumError(
+        `Trade validation failed: ${err instanceof Error ? err.message : String(err)}`,
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */,
+        err
+      );
+    }
+    const builderFee = buildBuilderFee(apiBuilder);
+    const slippageP = params.type === "market" /* Market */ ? BigInt(this.resolveSlippage(params.slippage)) : 0n;
+    const encoded = encodeOpenTrade(trade, builderFee, orderType, slippageP, this.contracts.trading);
+    return this.execute(encoded);
+  }
+  /**
+   * Close an open position (full or partial).
+   *
+   * `pairId` and `idx` come straight from a `Position` returned by
+   * `getOpenPositions` — pass them through directly:
+   *
+   * ```ts
+   * const { pairPositions } = await client.getOpenPositions();
+   * const { pairId, idx } = pairPositions[0].position;
+   * await client.closeTrade({ pairId, idx, price: '...', closePercent: 100 });
+   * ```
+   */
+  async closeTrade(params) {
+    try {
+      validateCloseParams({
+        a: Number(params.pairId),
+        t: params.idx,
+        p: params.price,
+        r: params.closePercent
+      });
+    } catch (err) {
+      throw new OstiumError(
+        `Close validation failed: ${err instanceof Error ? err.message : String(err)}`,
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */,
+        err
+      );
+    }
+    const pairIndex = BigInt(params.pairId);
+    const index = BigInt(params.idx);
+    const closePercentage = BigInt(Math.round(params.closePercent * 100));
+    const marketPrice = parsePrice(params.price);
+    const slippageP = BigInt(this.resolveSlippage(params.slippage));
+    const encoded = encodeCloseTradeMarket(
+      pairIndex,
+      index,
+      closePercentage,
+      marketPrice,
+      slippageP,
+      this.contracts.trading
+    );
+    return this.execute(encoded);
+  }
+  /**
+   * Cancel a pending order.
+   *
+   * TypeScript discriminates the params shape by `type` — required fields are
+   * enforced at compile time.
+   *
+   * @example Cancel a pending limit order
+   * ```ts
+   * const [order] = await client.getOpenOrders();
+   * await client.cancelOrder({ type: CancelOrderType.Limit, pairId: order.pairId, idx: order.idx });
+   * ```
+   * @example Cancel a timed-out market open
+   * ```ts
+   * await client.cancelOrder({ type: CancelOrderType.PendingOpen, orderId: 123 });
+   * ```
+   * @example Cancel a timed-out market close (retry: true re-submits the close)
+   * ```ts
+   * await client.cancelOrder({ type: CancelOrderType.PendingClose, orderId: 456, retry: true });
+   * ```
+   */
+  async cancelOrder(params) {
+    let encoded;
+    if (params.type === "limit" /* Limit */) {
+      const pairIdNum = Number(params.pairId);
+      const idxNum = Number(params.idx);
+      if (!Number.isFinite(pairIdNum) || !Number.isInteger(pairIdNum) || pairIdNum < 0 || !Number.isFinite(idxNum) || !Number.isInteger(idxNum) || idxNum < 0) {
+        throw new OstiumError(
+          `Invalid pairId (${params.pairId}) or idx (${params.idx}) for limit cancel`,
+          "VALIDATION_FAILED" /* VALIDATION_FAILED */
+        );
+      }
+      encoded = encodeCancelLimitOrder(
+        BigInt(pairIdNum),
+        BigInt(idxNum),
+        this.contracts.trading
+      );
+    } else if (params.type === "pendingClose" /* PendingClose */) {
+      if (params.orderId < 0) {
+        throw new OstiumError(
+          `Invalid orderId (${params.orderId}) for pending close cancel`,
+          "VALIDATION_FAILED" /* VALIDATION_FAILED */
+        );
+      }
+      encoded = encodeCloseTradeMarketTimeout(
+        BigInt(params.orderId),
+        params.retry ?? false,
+        this.contracts.trading
+      );
+    } else {
+      if (params.orderId < 0) {
+        throw new OstiumError(
+          `Invalid orderId (${params.orderId}) for pending open cancel`,
+          "VALIDATION_FAILED" /* VALIDATION_FAILED */
+        );
+      }
+      encoded = encodeOpenTradeMarketTimeout(BigInt(params.orderId), this.contracts.trading);
+    }
+    return this.execute(encoded);
+  }
+  /**
+   * Modify an open trade or a pending limit order.
+   *
+   * `pairId` and `idx` come straight from `getOpenPositions` (for TP/SL on open
+   * positions) or `getOpenOrders` (for limit-order edits):
+   *
+   * ```ts
+   * // Update TP/SL on an open position
+   * const { pairPositions } = await client.getOpenPositions();
+   * const { pairId, idx } = pairPositions[0].position;
+   * await client.modifyOrder({ pairId, idx, takeProfit: '...', stopLoss: '...' });
+   *
+   * // Re-price a pending limit order
+   * const [order] = await client.getOpenOrders();
+   * await client.modifyOrder({ pairId: order.pairId, idx: order.idx, price: '...' });
+   * ```
+   *
+   * - `price` provided → updates limit-order trigger price (with optional TP/SL).
+   * - `takeProfit` only → calls updateTp on an open trade.
+   * - `stopLoss` only → calls updateSl on an open trade.
+   * - Both `takeProfit` and `stopLoss` without `price` → throws (send two calls).
+   */
+  async modifyOrder(params) {
+    try {
+      validateModifyParams({
+        a: Number(params.pairId),
+        i: params.idx,
+        p: params.price,
+        tp: params.takeProfit,
+        sl: params.stopLoss
+      });
+    } catch (err) {
+      throw new OstiumError(
+        `Modify validation failed: ${err instanceof Error ? err.message : String(err)}`,
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */,
+        err
+      );
+    }
+    if (params.takeProfit && params.stopLoss && !params.price) {
+      throw new OstiumError(
+        "Cannot update both takeProfit and stopLoss simultaneously without a price. Send two separate modifyOrder calls.",
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */
+      );
+    }
+    const pairIndex = BigInt(params.pairId);
+    const index = BigInt(params.idx);
+    let encoded;
+    if (params.price) {
+      const price = parsePrice(params.price);
+      const tp = params.takeProfit ? parsePrice(params.takeProfit) : 0n;
+      const sl = params.stopLoss ? parsePrice(params.stopLoss) : 0n;
+      encoded = encodeUpdateOpenLimitOrder(pairIndex, index, price, tp, sl, this.contracts.trading);
+    } else if (params.takeProfit) {
+      encoded = encodeUpdateTp(pairIndex, index, parsePrice(params.takeProfit), this.contracts.trading);
+    } else if (params.stopLoss) {
+      encoded = encodeUpdateSl(pairIndex, index, parsePrice(params.stopLoss), this.contracts.trading);
+    } else {
+      throw new OstiumError(
+        "Either takeProfit or stopLoss must be provided when price is not specified",
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */
+      );
+    }
+    return this.execute(encoded);
+  }
+  /**
+   * Update collateral on an open position (isolated margin).
+   *
+   * `pairId` and `idx` come straight from a `Position` returned by `getOpenPositions`:
+   *
+   * ```ts
+   * const { pairPositions } = await client.getOpenPositions();
+   * const { pairId, idx } = pairPositions[0].position;
+   * await client.updateCollateral({ pairId, idx, amount: '50' });   // top up
+   * await client.updateCollateral({ pairId, idx, amount: '-25' });  // remove
+   * ```
+   *
+   * Positive amount → topUpCollateral (adds margin, reduces effective leverage).
+   * Negative amount → removeCollateral (removes margin, increases effective leverage).
+   *
+   * Checks USDC allowance before top-up operations.
+   */
+  async updateCollateral(params) {
+    const amount = parseFloat(params.amount);
+    if (Number.isNaN(amount) || amount === 0) {
+      throw new OstiumError(
+        `Invalid collateral amount: ${params.amount}`,
+        "VALIDATION_FAILED" /* VALIDATION_FAILED */
+      );
+    }
+    const pairIndex = BigInt(params.pairId);
+    const index = BigInt(params.idx);
+    const absAmount = parseUsdc(Math.abs(amount).toString());
+    let encoded;
+    if (amount > 0) {
+      const allowance = await this.checkUsdcAllowance(Math.abs(amount).toString());
+      if (!allowance.sufficient) {
+        throw new OstiumError(
+          `Insufficient USDC allowance for collateral top-up. Current: ${allowance.current}, Required: ${allowance.required}. Call approveUsdc() first.`,
+          "ALLOWANCE_INSUFFICIENT" /* ALLOWANCE_INSUFFICIENT */
+        );
+      }
+      encoded = encodeTopUpCollateral(pairIndex, index, absAmount, this.contracts.trading);
+    } else {
+      encoded = encodeRemoveCollateral(pairIndex, index, absAmount, this.contracts.trading);
+    }
+    return this.execute(encoded);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Subgraph reads (Hyperliquid-style API)
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * All trading pairs with computed `minSz`/`maxBSz`/`maxSSz`, live prices, and
+   * market-status flags. Pass `pairIds` to restrict to a subset.
+   */
+  getPairs(params) {
+    return this.subgraph.getPairs(params);
+  }
+  /** Live mid/bid/ask prices keyed by `pairId`. */
+  getAllPrices() {
+    return this.subgraph.getAllPrices();
+  }
+  /**
+   * Open positions + margin summary for a user. Defaults to the connected
+   * trader. Live prices and the current block number are fetched automatically.
+   */
+  async getOpenPositions(params) {
+    return this.subgraph.getOpenPositions({
+      user: params?.user ?? this.getTraderAddress(),
+      blockNumber: params?.blockNumber ?? await this.publicClient.getBlockNumber()
+    });
+  }
+  /**
+   * Executed fills, newest first.
+   *
+   * - `user` defaults to the connected trader. Pass `'ALL'` to fetch fills
+   *   across every trader (no trader filter).
+   * - `pairId` (optional) — restricts to a single pair.
+   * - `limit` (optional, default `1000`) — caps the result. Pass `Infinity` to
+   *   fetch every matching fill.
+   */
+  getFills(params) {
+    return this.subgraph.getFills({
+      user: params?.user ?? this.getTraderAddress(),
+      pairId: params?.pairId,
+      limit: params?.limit
+    });
+  }
+  /**
+   * Executed fills within a time range (Unix ms). Same filters as `getFills`,
+   * including the default `limit: 1000`.
+   */
+  getFillsByTime(params) {
+    return this.subgraph.getFillsByTime({
+      user: params.user ?? this.getTraderAddress(),
+      pairId: params.pairId,
+      limit: params.limit,
+      startTime: params.startTime,
+      endTime: params.endTime
+    });
+  }
+  /** Active limit orders for a user. Defaults to the connected trader. */
+  getOpenOrders(params) {
+    return this.subgraph.getOpenOrders({ user: params?.user ?? this.getTraderAddress() });
+  }
+  /**
+   * Fetch orders at any status — pending, executed, or cancelled.
+   *
+   * Pass `initiatedTxHashes: [result.txHash]` to poll by the submission hash, or
+   * `orderIds` by on-chain id. Without either, returns recent orders for the
+   * connected trader.
+   */
+  getOrders(params) {
+    const byId = params?.orderIds?.length;
+    const byTx = params?.initiatedTxHashes?.length;
+    return this.subgraph.getOrders({
+      ...params,
+      user: params?.user ?? (byId || byTx ? void 0 : this.getTraderAddress())
+    });
+  }
+  /**
+   * Simulate per-side slippage for a list of pairs and notionals.
+   * See {@link OstiumSubgraphClient.getSimSlippage} for full semantics.
+   */
+  getSimSlippage(params) {
+    return this.subgraph.getSimSlippage(params);
+  }
+  /**
+   * Build a synthetic bid/ask orderbook for one pair using exponentially-spaced
+   * notional levels capped at each side's remaining OI capacity.
+   * See {@link OstiumSubgraphClient.getSimOrderbook} for full semantics.
+   */
+  getSimOrderbook(params) {
+    return this.subgraph.getSimOrderbook(params);
+  }
+  /**
+   * Fetch OHLC candles for a pair from the builder API.
+   *
+   * `from` / `to` are Unix milliseconds; `resolution` is one of
+   * `"1"`, `"5"`, `"15"`, `"60"`, `"240"`, `"1D"`.
+   *
+   * ```ts
+   * const candles = await client.getCandles({
+   *   pairId: 0,
+   *   from: Date.now() - 30 * 86_400_000,
+   *   resolution: '1D',
+   * });
+   * ```
+   */
+  getCandles(params) {
+    return this.subgraph.getCandles(params);
+  }
+  /**
+   * Open a WebSocket connection to the live price stream.
+   *
+   * Optionally filter to a subset of pairs by `pairId` — same values as returned by
+   * `getPairs()`. When provided, the client sends `{ type: "subscribe", pairs }` on
+   * `open` (no `?pairs=` query on the URL). Omit `pairIds` to receive the full feed.
+   *
+   * ```ts
+   * const stream = client.streamPrices([0, 1]);  // BTC and ETH by pairId
+   * stream.onSnapshot(ticks => console.log(ticks));
+   * stream.onTick(tick => console.log(tick.pair, tick.mid));
+   * stream.subscribe([2]);    // add pair
+   * stream.unsubscribe([0]);  // remove pair
+   * stream.close();
+   * ```
+   *
+   * Requires Node.js 18+, Bun, or a browser environment. Bun’s `WebSocket` may fail
+   * some `https://` upgrades; use Node if the connection never reaches `open`.
+   */
+  streamPrices(pairIds) {
+    return this.subgraph.streamPrices(pairIds);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Internal helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  /**
+   * Core execution pipeline:
+   * 1. signer.prepare()  — optionally wraps in delegatedAction.
+   * 2. submitter.submit() — sends via EOA walletClient or Pimlico UserOp.
+   */
+  async execute(encoded) {
+    const { signer, submitter } = this.requireWriter();
+    const prepared = signer.prepare(encoded);
+    return submitter.submit(prepared);
+  }
+  /** Throws if the client is read-only; otherwise returns the signer + submitter. */
+  requireWriter() {
+    if (!this.signer || !this.submitter) {
+      throw new OstiumError(
+        "This client is read-only. Use one of the createSelfAnd*/createDelegatedAnd* factories to enable writes.",
+        "INVALID_CONFIG" /* INVALID_CONFIG */
+      );
+    }
+    return { signer: this.signer, submitter: this.submitter };
+  }
+  /** Direct EOA submission — used only in Self + Gasless for approveUsdc and setupGaslessDelegation. */
+  async submitDirectFromEoa(encoded) {
+    try {
+      return await this.eoaSubmit(encoded);
+    } catch (err) {
+      if (err instanceof OstiumError) throw err;
+      const msg = err instanceof Error ? err.message : String(err);
+      const lower = msg.toLowerCase();
+      if (lower.includes("revert")) {
+        throw new OstiumError(`Contract reverted: ${msg}`, "CONTRACT_ERROR" /* CONTRACT_ERROR */, err);
+      }
+      if (lower.includes("network") || lower.includes("timeout") || lower.includes("fetch")) {
+        throw new OstiumError(`Network error: ${msg}`, "NETWORK_ERROR" /* NETWORK_ERROR */, err);
+      }
+      throw new OstiumError(`Transaction failed: ${msg}`, "SUBMISSION_FAILED" /* SUBMISSION_FAILED */, err);
+    }
+  }
+  resolveSlippage(override) {
+    return override ?? this.defaultSlippageBps;
+  }
+};
+
+exports.CancelOrderType = CancelOrderType;
+exports.DEFAULT_BUILDER_API_URL = DEFAULT_BUILDER_API_URL;
+exports.DEFAULT_SLIPPAGE_PERCENTAGE = DEFAULT_SLIPPAGE_PERCENTAGE;
+exports.DEFAULT_SUBGRAPH_ENDPOINT = DEFAULT_SUBGRAPH_ENDPOINT;
+exports.DEFAULT_SUBGRAPH_ENDPOINT_TESTNET = DEFAULT_SUBGRAPH_ENDPOINT_TESTNET;
+exports.MAX_COLLATERAL_USD = MAX_COLLATERAL_USD;
+exports.MIN_COLLATERAL_USD = MIN_COLLATERAL_USD;
+exports.OrderType = OrderType;
+exports.OstiumClient = OstiumClient;
+exports.OstiumError = OstiumError;
+exports.OstiumErrorCode = OstiumErrorCode;
+exports.OstiumPriceStream = OstiumPriceStream;
+exports.OstiumSubgraphClient = OstiumSubgraphClient;
+exports.OstiumSubgraphError = OstiumSubgraphError;
+exports.OstiumSubgraphErrorCode = OstiumSubgraphErrorCode;
+exports.PRECISION_18 = PRECISION_18;
+exports.PRECISION_6 = PRECISION_6;
+exports.parseLeverage = parseLeverage;
+exports.parsePrice = parsePrice;
+exports.parseUsdc = parseUsdc;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map