@pear-protocol/symmio-client 0.2.4 → 0.2.5

package/dist/index.js

@@ -8,294 +8,72 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/constants/chains.ts
-var SupportedChainId = /* @__PURE__ */ ((SupportedChainId2) => {
-  SupportedChainId2[SupportedChainId2["ARBITRUM"] = 42161] = "ARBITRUM";
-  SupportedChainId2[SupportedChainId2["BASE"] = 8453] = "BASE";
-  SupportedChainId2[SupportedChainId2["BSC"] = 56] = "BSC";
-  SupportedChainId2[SupportedChainId2["POLYGON"] = 137] = "POLYGON";
-  SupportedChainId2[SupportedChainId2["MAINNET"] = 1] = "MAINNET";
-  return SupportedChainId2;
-})(SupportedChainId || {});
-var V3_CHAIN_IDS = [
-  42161 /* ARBITRUM */,
-  8453 /* BASE */
-];
-var FALLBACK_CHAIN_ID = 42161 /* ARBITRUM */;
-var CHAIN_NAMES = {
-  [42161 /* ARBITRUM */]: "Arbitrum One",
-  [8453 /* BASE */]: "Base",
-  [56 /* BSC */]: "BNB Chain",
-  [137 /* POLYGON */]: "Polygon",
-  [1 /* MAINNET */]: "Ethereum"
-};
+// src/types/common.ts
+var PositionType = /* @__PURE__ */ ((PositionType2) => {
+  PositionType2[PositionType2["LONG"] = 0] = "LONG";
+  PositionType2[PositionType2["SHORT"] = 1] = "SHORT";
+  return PositionType2;
+})(PositionType || {});
+var OrderType = /* @__PURE__ */ ((OrderType2) => {
+  OrderType2[OrderType2["LIMIT"] = 0] = "LIMIT";
+  OrderType2[OrderType2["MARKET"] = 1] = "MARKET";
+  return OrderType2;
+})(OrderType || {});
+var QuoteStatus = /* @__PURE__ */ ((QuoteStatus2) => {
+  QuoteStatus2[QuoteStatus2["PENDING"] = 0] = "PENDING";
+  QuoteStatus2[QuoteStatus2["LOCKED"] = 1] = "LOCKED";
+  QuoteStatus2[QuoteStatus2["CANCEL_PENDING"] = 2] = "CANCEL_PENDING";
+  QuoteStatus2[QuoteStatus2["CANCELED"] = 3] = "CANCELED";
+  QuoteStatus2[QuoteStatus2["OPENED"] = 4] = "OPENED";
+  QuoteStatus2[QuoteStatus2["CLOSE_PENDING"] = 5] = "CLOSE_PENDING";
+  QuoteStatus2[QuoteStatus2["CANCEL_CLOSE_PENDING"] = 6] = "CANCEL_CLOSE_PENDING";
+  QuoteStatus2[QuoteStatus2["CLOSED"] = 7] = "CLOSED";
+  QuoteStatus2[QuoteStatus2["LIQUIDATED"] = 8] = "LIQUIDATED";
+  QuoteStatus2[QuoteStatus2["EXPIRED"] = 9] = "EXPIRED";
+  return QuoteStatus2;
+})(QuoteStatus || {});
+var LiquidationStatus = /* @__PURE__ */ ((LiquidationStatus2) => {
+  LiquidationStatus2[LiquidationStatus2["NONE"] = 0] = "NONE";
+  LiquidationStatus2[LiquidationStatus2["PENDING"] = 1] = "PENDING";
+  LiquidationStatus2[LiquidationStatus2["ACTIVE"] = 2] = "ACTIVE";
+  LiquidationStatus2[LiquidationStatus2["COMPLETED"] = 3] = "COMPLETED";
+  return LiquidationStatus2;
+})(LiquidationStatus || {});
+var SoftLiquidationLevel = /* @__PURE__ */ ((SoftLiquidationLevel2) => {
+  SoftLiquidationLevel2[SoftLiquidationLevel2["NONE"] = 0] = "NONE";
+  SoftLiquidationLevel2[SoftLiquidationLevel2["WARNING"] = 1] = "WARNING";
+  SoftLiquidationLevel2[SoftLiquidationLevel2["CRITICAL"] = 2] = "CRITICAL";
+  SoftLiquidationLevel2[SoftLiquidationLevel2["EMERGENCY"] = 3] = "EMERGENCY";
+  return SoftLiquidationLevel2;
+})(SoftLiquidationLevel || {});
 
-// src/constants/addresses.ts
-var MULTI_ACCOUNT_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0x6273242a7E88b3De90822b31648C212215caaFE4",
-  [8453 /* BASE */]: "0xE43166cE17d3511B09438a359dAa53513225101D"
-};
-var SYMMIO_DIAMOND_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0x8F06459f184553e5d04F07F868720BDaCAB39395",
-  [8453 /* BASE */]: "0x91Cf2D8Ed503EC52768999aA6D8DBeA6e52dbe43"
-};
-var COLLATERAL_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-  [8453 /* BASE */]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-};
-var CLEARING_HOUSE_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0x0000000000000000000000000000000000000000",
-  [8453 /* BASE */]: "0x0000000000000000000000000000000000000000"
-};
-var SIGNATURE_STORE_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0x94eEa58De1C8945c342dB4bE9670301638E403e2"
-};
-var DEFAULT_PARTY_B_ADDRESS = {
-  [42161 /* ARBITRUM */]: "0x00c069d68bc7420740460DBC3cc3fFF9b3742421",
-  [8453 /* BASE */]: "0x1EcAbF0Eba136920677C9575FAccee36f30592cf"
-};
-var COLLATERAL_DECIMALS = {
-  [42161 /* ARBITRUM */]: 6,
-  [8453 /* BASE */]: 6
-};
-function getAddress(addressMap, chainId, name) {
-  const addr = addressMap[chainId];
-  if (!addr || addr === "0x0000000000000000000000000000000000000000") {
-    throw new Error(`${name} address not configured for chain ${chainId}`);
-  }
-  return addr;
-}
+// src/types/affiliate.ts
+var AffiliateFeeLevel = /* @__PURE__ */ ((AffiliateFeeLevel2) => {
+  AffiliateFeeLevel2[AffiliateFeeLevel2["USER_SYMBOL"] = 0] = "USER_SYMBOL";
+  AffiliateFeeLevel2[AffiliateFeeLevel2["USER_DEFAULT"] = 1] = "USER_DEFAULT";
+  AffiliateFeeLevel2[AffiliateFeeLevel2["SYMBOL"] = 2] = "SYMBOL";
+  AffiliateFeeLevel2[AffiliateFeeLevel2["AFFILIATE_DEFAULT"] = 3] = "AFFILIATE_DEFAULT";
+  return AffiliateFeeLevel2;
+})(AffiliateFeeLevel || {});
 
-// src/constants/defaults.ts
-var MARKET_ORDER_DEADLINE = 300n;
-var LIMIT_ORDER_DEADLINE = 311040120n;
-var MARKET_PRICE_COEFFICIENT = 1.01;
-var MAX_LEVERAGE = 50;
-var DEFAULT_PRECISION = 2;
-var GAS_MARGIN_PERCENTAGE = 20n;
-var STANDARD_WITHDRAW_COOLDOWN = 43200;
-var MUON_BASE_URLS = [
-  "https://muon-oracle1.rasa.capital/v1/",
-  "https://muon-oracle2.rasa.capital/v1/",
-  "https://muon-oracle3.rasa.capital/v1/",
-  "https://muon-oracle4.rasa.capital/v1/"
-];
-var MUON_APP_NAME = "symmio";
-var MUON_REQUEST_TIMEOUT = 15e3;
-var HEDGER_BASE_URLS = {
-  [42161 /* ARBITRUM */]: "https://www.perps-streaming.com/v1/42161a/0x6273242a7E88b3De90822b31648C212215caaFE4",
-  [8453 /* BASE */]: "https://www.perps-streaming.com/v1/8453a/0x6273242a7E88b3De90822b31648C212215caaFE4"
-};
-var SymmioSDKError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "SymmioSDKError";
-  }
-};
-function validateAddress(address, name) {
-  if (!viem.isAddress(address)) {
-    throw new SymmioSDKError(
-      `Invalid ${name} address: ${address}`,
-      "INVALID_ADDRESS"
-    );
-  }
-  return address;
-}
-function validateAmount(amount, name) {
-  if (amount <= 0n) {
-    throw new SymmioSDKError(
-      `${name} must be a positive amount, got ${amount}`,
-      "INVALID_AMOUNT"
-    );
-  }
-}
-function validateChainId(chainId, supportedChains) {
-  if (!supportedChains.includes(chainId)) {
-    throw new SymmioSDKError(
-      `Chain ${chainId} is not supported. Supported: ${supportedChains.join(", ")}`,
-      "UNSUPPORTED_CHAIN"
-    );
-  }
-}
-function validateDeadline(deadline) {
-  const now = BigInt(Math.floor(Date.now() / 1e3));
-  if (deadline <= now) {
-    throw new SymmioSDKError(
-      `Deadline ${deadline} is in the past (current: ${now})`,
-      "EXPIRED_DEADLINE"
-    );
-  }
-}
-function validateQuantity(quantity) {
-  if (quantity <= 0n) {
-    throw new SymmioSDKError(
-      `Quantity must be positive, got ${quantity}`,
-      "INVALID_QUANTITY"
-    );
-  }
-}
+// src/types/clearingHouse.ts
+var ClearingHouseLiquidationStatus = /* @__PURE__ */ ((ClearingHouseLiquidationStatus2) => {
+  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["INITIATED"] = 0] = "INITIATED";
+  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["DEALLOCATED"] = 1] = "DEALLOCATED";
+  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["POSITIONS_CLOSED"] = 2] = "POSITIONS_CLOSED";
+  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["SETTLED"] = 3] = "SETTLED";
+  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["COMPLETED"] = 4] = "COMPLETED";
+  return ClearingHouseLiquidationStatus2;
+})(ClearingHouseLiquidationStatus || {});
 
-// src/clients/muon.ts
-function parseSchnorrSign(sigs) {
-  return {
-    signature: BigInt(sigs.signature),
-    owner: sigs.owner,
-    nonce: sigs.nonce
-  };
-}
-function parseSingleUpnlSig(result) {
-  const data = result["result"];
-  if (!data) {
-    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
-  }
-  const sigData = data["data"];
-  const signParams = sigData?.["signParams"] ?? data["signParams"];
-  const signatures = sigData?.["signatures"] ?? data["signatures"];
-  return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
-    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
-    sigs: parseSchnorrSign(
-      signParams["sigs"] ?? signatures?.[1]
-    )
-  };
-}
-function parseSingleUpnlAndPriceSig(result) {
-  const data = result["result"];
-  if (!data) {
-    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
-  }
-  const sigData = data["data"];
-  const signParams = sigData?.["signParams"] ?? data["signParams"];
-  const signatures = sigData?.["signatures"] ?? data["signatures"];
-  return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
-    price: BigInt(signParams["price"]),
-    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
-    sigs: parseSchnorrSign(
-      signParams["sigs"] ?? signatures?.[1]
-    )
-  };
-}
-function parseBatchSig(result) {
-  const data = result["result"];
-  if (!data) {
-    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
-  }
-  const sigData = data["data"];
-  const signParams = sigData?.["signParams"] ?? data["signParams"];
-  const signatures = sigData?.["signatures"] ?? data["signatures"];
-  return {
-    reqId: signParams["reqId"],
-    timestamp: BigInt(signParams["timestamp"]),
-    upnl: BigInt(signParams["upnl"]),
-    prices: signParams["prices"].map((p) => BigInt(p)),
-    symbolIds: signParams["symbolIds"].map((s) => BigInt(s)),
-    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
-    sigs: parseSchnorrSign(
-      signParams["sigs"] ?? signatures?.[1]
-    )
-  };
-}
-var MuonClient = class {
-  baseUrls;
-  appName;
-  timeout;
-  constructor(config) {
-    this.baseUrls = config?.baseUrls ?? MUON_BASE_URLS;
-    this.appName = config?.appName ?? MUON_APP_NAME;
-    this.timeout = config?.timeout ?? MUON_REQUEST_TIMEOUT;
-  }
-  /**
-   * Sends a request to Muon, trying each base URL in order until one succeeds.
-   */
-  async sendRequest(method, params) {
-    let lastError = null;
-    for (const baseUrl of this.baseUrls) {
-      try {
-        const searchParams = new URLSearchParams({
-          app: this.appName,
-          method
-        });
-        for (const [key, value] of Object.entries(params)) {
-          searchParams.set(`params[${key}]`, value);
-        }
-        const url = `${baseUrl}?${searchParams.toString()}`;
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const response = await fetch(url, { signal: controller.signal });
-        clearTimeout(timeoutId);
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const json = await response.json();
-        if (json["error"]) {
-          throw new Error(`Muon error: ${JSON.stringify(json["error"])}`);
-        }
-        return json;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-      }
-    }
-    throw new SymmioSDKError(
-      `All Muon nodes failed. Last error: ${lastError?.message}`,
-      "MUON_REQUEST_FAILED"
-    );
-  }
-  /**
-   * Gets a UPnL + Price signature for opening a position (sendQuote).
-   */
-  async getQuoteSig(params) {
-    const result = await this.sendRequest("uPnl_A_withSymbolPrice", {
-      partyA: params.partyA,
-      chainId: params.chainId.toString(),
-      symmio: params.symmioAddress,
-      symbolId: params.symbolId.toString()
-    });
-    return parseSingleUpnlAndPriceSig(result);
-  }
-  /**
-   * Gets a UPnL signature for deallocating funds.
-   * v0.8.5: Now includes pendingBalance for safe deallocate.
-   */
-  async getDeallocateSig(params) {
-    const result = await this.sendRequest("uPnl_A", {
-      partyA: params.partyA,
-      chainId: params.chainId.toString(),
-      symmio: params.symmioAddress
-    });
-    return parseSingleUpnlSig(result);
-  }
-  /**
-   * Gets a batch signature for multiple positions (v0.8.5).
-   * Single signature covers multiple symbol prices for batch open/close.
-   */
-  async getBatchSig(params) {
-    const result = await this.sendRequest("uPnl_A_withSymbolPrices", {
-      partyA: params.partyA,
-      chainId: params.chainId.toString(),
-      symmio: params.symmioAddress,
-      symbolIds: params.symbolIds.join(",")
-    });
-    return parseBatchSig(result);
-  }
-};
-
-// src/actions/account.ts
-var account_exports = {};
-__export(account_exports, {
-  addAccount: () => addAccount,
-  editAccountName: () => editAccountName,
-  getAccounts: () => getAccounts,
-  getAccountsLength: () => getAccountsLength,
-  getOwner: () => getOwner,
-  prepareAddAccount: () => prepareAddAccount,
-  prepareEditAccountName: () => prepareEditAccountName
-});
+// src/types/instant.ts
+var InstantCloseStatus = /* @__PURE__ */ ((InstantCloseStatus2) => {
+  InstantCloseStatus2[InstantCloseStatus2["STARTED"] = 0] = "STARTED";
+  InstantCloseStatus2[InstantCloseStatus2["PROCESSING"] = 1] = "PROCESSING";
+  InstantCloseStatus2[InstantCloseStatus2["FAILED"] = 2] = "FAILED";
+  InstantCloseStatus2[InstantCloseStatus2["FINISHED"] = 3] = "FINISHED";
+  return InstantCloseStatus2;
+})(InstantCloseStatus || {});
 
 // src/abis/MultiAccount.ts
 var MultiAccountABI = [
@@ -702,188 +480,6 @@ var MultiAccountABI = [
   { name: "RoleRevoked", type: "event", inputs: [{ name: "role", type: "bytes32", indexed: true }, { name: "account", type: "address", indexed: true }, { name: "sender", type: "address", indexed: true }] }
 ];
 
-// src/utils/gas.ts
-function calculateGasMargin(estimatedGas) {
-  return estimatedGas * (100n + GAS_MARGIN_PERCENTAGE) / 100n;
-}
-
-// src/actions/account.ts
-function prepareAddAccount(multiAccount, account, name) {
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "addAccount",
-    args: [name]
-  });
-  return {
-    functionName: "addAccount",
-    args: [name],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-function prepareEditAccountName(multiAccount, account, accountAddress, name) {
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "editAccountName",
-    args: [accountAddress, name]
-  });
-  return {
-    functionName: "editAccountName",
-    args: [accountAddress, name],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-async function addAccount(walletClient, publicClient, multiAccount, name) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareAddAccount(multiAccount, account, name);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function editAccountName(walletClient, publicClient, multiAccount, accountAddress, name) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareEditAccountName(multiAccount, account, accountAddress, name);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function getAccounts(publicClient, multiAccount, user, start = 0, size = 100) {
-  const result = await publicClient.readContract({
-    address: multiAccount,
-    abi: MultiAccountABI,
-    functionName: "getAccounts",
-    args: [user, BigInt(start), BigInt(size)]
-  });
-  return result;
-}
-async function getAccountsLength(publicClient, multiAccount, user) {
-  const result = await publicClient.readContract({
-    address: multiAccount,
-    abi: MultiAccountABI,
-    functionName: "getAccountsLength",
-    args: [user]
-  });
-  return Number(result);
-}
-async function getOwner(publicClient, multiAccount, accountAddress) {
-  const result = await publicClient.readContract({
-    address: multiAccount,
-    abi: MultiAccountABI,
-    functionName: "owners",
-    args: [accountAddress]
-  });
-  return result;
-}
-
-// src/actions/deposit.ts
-var deposit_exports = {};
-__export(deposit_exports, {
-  deposit: () => deposit,
-  depositAndAllocate: () => depositAndAllocate,
-  prepareDeposit: () => prepareDeposit,
-  prepareDepositAndAllocate: () => prepareDepositAndAllocate
-});
-function prepareDeposit(multiAccount, account, params) {
-  validateAmount(params.amount, "deposit amount");
-  validateAddress(params.account, "account");
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "depositForAccount",
-    args: [params.account, params.amount]
-  });
-  return {
-    functionName: "depositForAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-function prepareDepositAndAllocate(multiAccount, account, params) {
-  validateAmount(params.amount, "deposit amount");
-  validateAddress(params.account, "account");
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "depositAndAllocateForAccount",
-    args: [params.account, params.amount]
-  });
-  return {
-    functionName: "depositAndAllocateForAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-async function deposit(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareDeposit(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function depositAndAllocate(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareDepositAndAllocate(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-
-// src/actions/withdraw.ts
-var withdraw_exports = {};
-__export(withdraw_exports, {
-  prepareWithdraw: () => prepareWithdraw,
-  withdraw: () => withdraw
-});
-function prepareWithdraw(multiAccount, account, params) {
-  validateAmount(params.amount, "withdraw amount");
-  validateAddress(params.account, "account");
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount]
-  });
-  return {
-    functionName: "withdrawFromAccount",
-    args: [params.account, params.amount],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-async function withdraw(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareWithdraw(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-
-// src/actions/allocate.ts
-var allocate_exports = {};
-__export(allocate_exports, {
-  allocate: () => allocate,
-  deallocate: () => deallocate,
-  internalTransfer: () => internalTransfer,
-  prepareAllocate: () => prepareAllocate,
-  prepareDeallocate: () => prepareDeallocate,
-  prepareInternalTransfer: () => prepareInternalTransfer
-});
-
 // src/abis/SymmioDiamond.ts
 var SymmioDiamondABI = [
   {
@@ -23268,1687 +22864,1754 @@ var SymmioDiamondABI = [
     type: "function"
   }
 ];
-function encodeCall(abi, functionName, args) {
-  return viem.encodeFunctionData({
-    abi,
-    functionName,
-    args
-  });
-}
-function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
-  const data = viem.encodeFunctionData({
-    abi: accountDiamondAbi,
-    functionName: "_call",
-    args: [subAccount, callDatas]
-  });
-  return {
-    functionName: "_call",
-    args: [subAccount, callDatas],
-    data
-  };
-}
-
-// src/actions/allocate.ts
-function prepareAllocate(multiAccount, account, subAccount, params) {
-  validateAmount(params.amount, "allocate amount");
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "allocate",
-    args: [params.amount]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function prepareDeallocate(multiAccount, account, subAccount, params) {
-  validateAmount(params.amount, "deallocate amount");
-  const muonSig = {
-    reqId: params.upnlSig.reqId,
-    timestamp: params.upnlSig.timestamp,
-    upnl: params.upnlSig.upnl,
-    gatewaySignature: params.upnlSig.gatewaySignature,
-    sigs: {
-      signature: params.upnlSig.sigs.signature,
-      owner: params.upnlSig.sigs.owner,
-      nonce: params.upnlSig.sigs.nonce
-    }
-  };
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "deallocate",
-    args: [params.amount, muonSig]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function prepareInternalTransfer(multiAccount, account, subAccount, params) {
-  validateAmount(params.amount, "transfer amount");
-  validateAddress(params.recipient, "recipient");
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "internalTransfer",
-    args: [params.recipient, params.amount]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-async function allocate(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareAllocate(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function deallocate(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareDeallocate(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function internalTransfer(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareInternalTransfer(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-
-// src/actions/trade.ts
-var trade_exports = {};
-__export(trade_exports, {
-  preparePairTrade: () => preparePairTrade,
-  prepareSendQuote: () => prepareSendQuote,
-  sendQuote: () => sendQuote
-});
-function buildUpnlSigTuple(sig) {
-  return {
-    reqId: sig.reqId,
-    timestamp: sig.timestamp,
-    upnl: sig.upnl,
-    price: sig.price,
-    gatewaySignature: sig.gatewaySignature,
-    sigs: {
-      signature: sig.sigs.signature,
-      owner: sig.sigs.owner,
-      nonce: sig.sigs.nonce
-    }
-  };
-}
-function prepareSendQuote(multiAccount, account, subAccount, params) {
-  validateQuantity(params.quantity);
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "sendQuoteWithAffiliate",
-    args: [
-      params.partyBsWhiteList,
-      BigInt(params.symbolId),
-      params.positionType,
-      params.orderType,
-      params.price,
-      params.quantity,
-      params.cva,
-      params.lf,
-      params.partyAmm,
-      params.partyBmm,
-      params.maxFundingRate,
-      params.deadline,
-      params.affiliate,
-      buildUpnlSigTuple(params.upnlSig)
-    ]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function preparePairTrade(multiAccount, account, subAccount, longParams, shortParams) {
-  const longData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "sendQuoteWithAffiliate",
-    args: [
-      longParams.partyBsWhiteList,
-      BigInt(longParams.symbolId),
-      longParams.positionType,
-      longParams.orderType,
-      longParams.price,
-      longParams.quantity,
-      longParams.cva,
-      longParams.lf,
-      longParams.partyAmm,
-      longParams.partyBmm,
-      longParams.maxFundingRate,
-      longParams.deadline,
-      longParams.affiliate,
-      buildUpnlSigTuple(longParams.upnlSig)
-    ]
-  });
-  const shortData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "sendQuoteWithAffiliate",
-    args: [
-      shortParams.partyBsWhiteList,
-      BigInt(shortParams.symbolId),
-      shortParams.positionType,
-      shortParams.orderType,
-      shortParams.price,
-      shortParams.quantity,
-      shortParams.cva,
-      shortParams.lf,
-      shortParams.partyAmm,
-      shortParams.partyBmm,
-      shortParams.maxFundingRate,
-      shortParams.deadline,
-      shortParams.affiliate,
-      buildUpnlSigTuple(shortParams.upnlSig)
-    ]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [longData, shortData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-async function sendQuote(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareSendQuote(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
 
-// src/actions/close.ts
-var close_exports = {};
-__export(close_exports, {
-  closePosition: () => closePosition,
-  prepareClosePosition: () => prepareClosePosition,
-  preparePairClose: () => preparePairClose
-});
-function prepareClosePosition(multiAccount, account, subAccount, params) {
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "requestToClosePosition",
-    args: [
-      params.quoteId,
-      params.closePrice,
-      params.quantityToClose,
-      params.orderType,
-      params.deadline
-    ]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-function preparePairClose(multiAccount, account, subAccount, longClose, shortClose) {
-  const longData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "requestToClosePosition",
-    args: [
-      longClose.quoteId,
-      longClose.closePrice,
-      longClose.quantityToClose,
-      longClose.orderType,
-      longClose.deadline
-    ]
-  });
-  const shortData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "requestToClosePosition",
-    args: [
-      shortClose.quoteId,
-      shortClose.closePrice,
-      shortClose.quantityToClose,
-      shortClose.orderType,
-      shortClose.deadline
-    ]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [longData, shortData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: multiAccount, data: proxy.data, value: 0n }
-  };
-}
-async function closePosition(walletClient, publicClient, multiAccount, subAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareClosePosition(multiAccount, account, subAccount, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-
-// src/actions/cancel.ts
-var cancel_exports = {};
-__export(cancel_exports, {
-  cancelCloseRequest: () => cancelCloseRequest,
-  cancelQuote: () => cancelQuote,
-  forceCancelCloseRequest: () => forceCancelCloseRequest,
-  forceCancelQuote: () => forceCancelQuote,
-  prepareCancelCloseRequest: () => prepareCancelCloseRequest,
-  prepareCancelQuote: () => prepareCancelQuote,
-  prepareForceCancelCloseRequest: () => prepareForceCancelCloseRequest,
-  prepareForceCancelQuote: () => prepareForceCancelQuote
-});
-function prepareCancelAction(accountDiamond, account, subAccount, functionName, quoteId) {
-  const innerData = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName,
-    args: [quoteId]
-  });
-  const proxy = wrapInProxyCall(
-    MultiAccountABI,
-    subAccount,
-    [innerData]
-  );
-  return {
-    functionName: "_call",
-    args: proxy.args,
-    config: { account, to: accountDiamond, data: proxy.data, value: 0n }
-  };
-}
-async function executeCancelAction(walletClient, publicClient, accountDiamond, subAccount, functionName, quoteId) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareCancelAction(
-    accountDiamond,
-    account,
-    subAccount,
-    functionName,
-    quoteId
-  );
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-function prepareCancelQuote(accountDiamond, account, subAccount, quoteId) {
-  return prepareCancelAction(
-    accountDiamond,
-    account,
-    subAccount,
-    "requestToCancelQuote",
-    quoteId
-  );
-}
-function prepareCancelCloseRequest(accountDiamond, account, subAccount, quoteId) {
-  return prepareCancelAction(
-    accountDiamond,
-    account,
-    subAccount,
-    "requestToCancelCloseRequest",
-    quoteId
-  );
-}
-function prepareForceCancelQuote(accountDiamond, account, subAccount, quoteId) {
-  return prepareCancelAction(
-    accountDiamond,
-    account,
-    subAccount,
-    "forceCancelQuote",
-    quoteId
-  );
-}
-function prepareForceCancelCloseRequest(accountDiamond, account, subAccount, quoteId) {
-  return prepareCancelAction(
-    accountDiamond,
-    account,
-    subAccount,
-    "forceCancelCloseRequest",
-    quoteId
-  );
-}
-async function cancelQuote(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
-  return executeCancelAction(
-    walletClient,
-    publicClient,
-    accountDiamond,
-    subAccount,
-    "requestToCancelQuote",
-    quoteId
-  );
-}
-async function cancelCloseRequest(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
-  return executeCancelAction(
-    walletClient,
-    publicClient,
-    accountDiamond,
-    subAccount,
-    "requestToCancelCloseRequest",
-    quoteId
-  );
-}
-async function forceCancelQuote(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
-  return executeCancelAction(
-    walletClient,
-    publicClient,
-    accountDiamond,
-    subAccount,
-    "forceCancelQuote",
-    quoteId
-  );
-}
-async function forceCancelCloseRequest(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
-  return executeCancelAction(
-    walletClient,
-    publicClient,
-    accountDiamond,
-    subAccount,
-    "forceCancelCloseRequest",
-    quoteId
-  );
-}
-
-// src/actions/approval.ts
-var approval_exports = {};
-__export(approval_exports, {
-  ApprovalState: () => ApprovalState,
-  approve: () => approve,
-  getAllowance: () => getAllowance,
-  getApprovalState: () => getApprovalState,
-  getBalance: () => getBalance,
-  getDecimals: () => getDecimals,
-  prepareApprove: () => prepareApprove
-});
-
-// src/abis/ERC20.ts
-var ERC20ABI = [
+// src/abis/ClearingHouse.ts
+var ClearingHouseABI = [
+  // ─── Liquidation Lifecycle ────────────────────────────────────
   {
-    name: "approve",
+    name: "initiateLiquidation",
     type: "function",
     stateMutability: "nonpayable",
     inputs: [
-      { name: "spender", type: "address" },
-      { name: "amount", type: "uint256" }
+      { name: "partyA", type: "address" },
+      { name: "partyB", type: "address" }
     ],
-    outputs: [{ name: "success", type: "bool" }]
+    outputs: [{ name: "liquidationId", type: "uint256" }]
   },
   {
-    name: "allowance",
+    name: "deallocateLiquidation",
     type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "owner", type: "address" },
-      { name: "spender", type: "address" }
-    ],
-    outputs: [{ name: "remaining", type: "uint256" }]
+    stateMutability: "nonpayable",
+    inputs: [{ name: "liquidationId", type: "uint256" }],
+    outputs: []
   },
   {
-    name: "balanceOf",
+    name: "closePositionsInLiquidation",
     type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "account", type: "address" }],
-    outputs: [{ name: "balance", type: "uint256" }]
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "liquidationId", type: "uint256" },
+      { name: "quoteIds", type: "uint256[]" },
+      { name: "closePrices", type: "uint256[]" }
+    ],
+    outputs: []
   },
   {
-    name: "decimals",
+    name: "distributeLiquidation",
     type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "decimals", type: "uint8" }]
+    stateMutability: "nonpayable",
+    inputs: [{ name: "liquidationId", type: "uint256" }],
+    outputs: []
   },
   {
-    name: "symbol",
+    name: "settleLiquidation",
     type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "symbol", type: "string" }]
+    stateMutability: "nonpayable",
+    inputs: [{ name: "liquidationId", type: "uint256" }],
+    outputs: []
   },
+  // ─── Soft Liquidation (v0.8.5) ────────────────────────────────
   {
-    name: "totalSupply",
+    name: "applySoftLiquidationPenalty",
     type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "supply", type: "uint256" }]
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "partyB", type: "address" },
+      { name: "level", type: "uint8" }
+    ],
+    outputs: []
   },
   {
-    name: "transfer",
+    name: "setSoftLiquidationThreshold",
     type: "function",
     stateMutability: "nonpayable",
     inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
+      { name: "level", type: "uint8" },
+      { name: "ratio", type: "uint256" },
+      { name: "penalty", type: "uint256" }
     ],
-    outputs: [{ name: "success", type: "bool" }]
+    outputs: []
   },
+  // ─── Auto-Takeover ────────────────────────────────────────────
   {
-    name: "mint",
+    name: "autoTakeover",
     type: "function",
     stateMutability: "nonpayable",
     inputs: [
-      { name: "to", type: "address" },
-      { name: "amount", type: "uint256" }
+      { name: "liquidationId", type: "uint256" },
+      { name: "newPartyB", type: "address" }
     ],
     outputs: []
-  }
-];
-
-// src/actions/approval.ts
-var ApprovalState = /* @__PURE__ */ ((ApprovalState2) => {
-  ApprovalState2["UNKNOWN"] = "UNKNOWN";
-  ApprovalState2["NOT_APPROVED"] = "NOT_APPROVED";
-  ApprovalState2["PENDING"] = "PENDING";
-  ApprovalState2["APPROVED"] = "APPROVED";
-  return ApprovalState2;
-})(ApprovalState || {});
-function prepareApprove(tokenAddress, account, spender, amount) {
-  validateAddress(spender, "spender");
-  const data = viem.encodeFunctionData({
-    abi: ERC20ABI,
-    functionName: "approve",
-    args: [spender, amount]
-  });
-  return {
-    functionName: "approve",
-    args: [spender, amount],
-    config: { account, to: tokenAddress, data, value: 0n }
-  };
-}
-async function approve(walletClient, publicClient, tokenAddress, spender, amount) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareApprove(tokenAddress, account, spender, amount);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function getAllowance(publicClient, tokenAddress, owner, spender) {
-  return await publicClient.readContract({
-    address: tokenAddress,
-    abi: ERC20ABI,
-    functionName: "allowance",
-    args: [owner, spender]
-  });
-}
-async function getBalance(publicClient, tokenAddress, account) {
-  return await publicClient.readContract({
-    address: tokenAddress,
-    abi: ERC20ABI,
-    functionName: "balanceOf",
-    args: [account]
-  });
-}
-async function getDecimals(publicClient, tokenAddress) {
-  return await publicClient.readContract({
-    address: tokenAddress,
-    abi: ERC20ABI,
-    functionName: "decimals"
-  });
-}
-async function getApprovalState(publicClient, tokenAddress, owner, spender, requiredAmount) {
-  try {
-    const allowance = await getAllowance(publicClient, tokenAddress, owner, spender);
-    if (allowance >= requiredAmount) {
-      return "APPROVED" /* APPROVED */;
-    }
-    return "NOT_APPROVED" /* NOT_APPROVED */;
-  } catch {
-    return "UNKNOWN" /* UNKNOWN */;
-  }
-}
-
-// src/actions/delegation.ts
-var delegation_exports = {};
-__export(delegation_exports, {
-  delegateAccess: () => delegateAccess,
-  hasDelegatedAccess: () => hasDelegatedAccess,
-  prepareDelegateAccess: () => prepareDelegateAccess,
-  prepareProposeRevoke: () => prepareProposeRevoke,
-  prepareRevokeAccess: () => prepareRevokeAccess,
-  proposeRevoke: () => proposeRevoke,
-  revokeAccess: () => revokeAccess
-});
-function prepareDelegateAccess(multiAccount, account, params) {
-  validateAddress(params.account, "subAccount");
-  validateAddress(params.target, "target");
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "delegateAccesses",
-    args: [params.account, params.target, params.selectors, params.activate]
-  });
-  return {
-    functionName: "delegateAccesses",
-    args: [params.account, params.target, params.selectors, params.activate],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-function prepareProposeRevoke(multiAccount, account, params) {
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "proposeToRevokeAccesses",
-    args: [params.account, params.target, params.selectors]
-  });
-  return {
-    functionName: "proposeToRevokeAccesses",
-    args: [params.account, params.target, params.selectors],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-function prepareRevokeAccess(multiAccount, account, params) {
-  const data = viem.encodeFunctionData({
-    abi: MultiAccountABI,
-    functionName: "revokeAccesses",
-    args: [params.account, params.target, params.selectors]
-  });
-  return {
-    functionName: "revokeAccesses",
-    args: [params.account, params.target, params.selectors],
-    config: { account, to: multiAccount, data, value: 0n }
-  };
-}
-async function delegateAccess(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareDelegateAccess(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function proposeRevoke(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareProposeRevoke(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function revokeAccess(walletClient, publicClient, multiAccount, params) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareRevokeAccess(multiAccount, account, params);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function hasDelegatedAccess(publicClient, multiAccount, params) {
-  validateAddress(params.account, "subAccount");
-  validateAddress(params.target, "target");
-  const result = await publicClient.readContract({
-    address: multiAccount,
-    abi: MultiAccountABI,
-    functionName: "delegatedAccesses",
-    args: [params.account, params.target, params.selector]
-  });
-  return Boolean(result);
-}
-
-// src/actions/signature.ts
-var signature_exports = {};
-__export(signature_exports, {
-  getCurrentMessage: () => getCurrentMessage,
-  hasSignedCurrentVersion: () => hasSignedCurrentVersion,
-  prepareStoreSignature: () => prepareStoreSignature,
-  signTermsMessage: () => signTermsMessage,
-  storeSignature: () => storeSignature
-});
-
-// src/abis/SignatureStore.ts
-var SignatureStoreABI = [
+  },
+  // ─── ADL Assurance ────────────────────────────────────────────
   {
-    name: "storeSignatureForCurrentVersion",
+    name: "depositADLAssurance",
     type: "function",
     stateMutability: "nonpayable",
-    inputs: [{ name: "signature", type: "bytes" }],
+    inputs: [
+      { name: "partyB", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
     outputs: []
   },
   {
-    name: "hasCurrentVersionSignature",
+    name: "slashADLAssurance",
     type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ name: "hasSigned", type: "bool" }]
+    stateMutability: "nonpayable",
+    inputs: [{ name: "partyB", type: "address" }],
+    outputs: []
   },
+  // ─── Insurance Vault ──────────────────────────────────────────
   {
-    name: "getSignature",
+    name: "setMaxLiquidatorProfit",
     type: "function",
-    stateMutability: "view",
-    inputs: [
-      { name: "version", type: "uint256" },
-      { name: "user", type: "address" }
-    ],
-    outputs: [{ name: "signature", type: "bytes" }]
+    stateMutability: "nonpayable",
+    inputs: [{ name: "maxProfit", type: "uint256" }],
+    outputs: []
   },
   {
-    name: "getCurrentVersionMessage",
+    name: "reimbursePartyB",
     type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "message", type: "string" }]
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "partyB", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
   },
+  // ─── View Functions ───────────────────────────────────────────
   {
-    name: "getCurrentVersion",
+    name: "getLiquidation",
     type: "function",
     stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "version", type: "uint256" }]
+    inputs: [{ name: "liquidationId", type: "uint256" }],
+    outputs: [
+      {
+        name: "liquidation",
+        type: "tuple",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "partyA", type: "address" },
+          { name: "partyB", type: "address" },
+          { name: "status", type: "uint8" },
+          { name: "deallocatedAmount", type: "uint256" },
+          { name: "settledAmount", type: "uint256" },
+          { name: "createdAt", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  // ─── Events ───────────────────────────────────────────────────
+  {
+    name: "LiquidationInitiated",
+    type: "event",
+    inputs: [
+      { name: "liquidationId", type: "uint256", indexed: true },
+      { name: "partyA", type: "address", indexed: true },
+      { name: "partyB", type: "address", indexed: true }
+    ]
+  },
+  {
+    name: "LiquidationSettled",
+    type: "event",
+    inputs: [
+      { name: "liquidationId", type: "uint256", indexed: true }
+    ]
+  },
+  {
+    name: "SoftLiquidationPenalty",
+    type: "event",
+    inputs: [
+      { name: "partyB", type: "address", indexed: true },
+      { name: "level", type: "uint8", indexed: false },
+      { name: "penalty", type: "uint256", indexed: false }
+    ]
   }
 ];
 
-// src/actions/signature.ts
-function prepareStoreSignature(signatureStore, account, signature) {
-  const data = viem.encodeFunctionData({
-    abi: SignatureStoreABI,
-    functionName: "storeSignatureForCurrentVersion",
-    args: [signature]
-  });
-  return {
-    functionName: "storeSignatureForCurrentVersion",
-    args: [signature],
-    config: { account, to: signatureStore, data, value: 0n }
-  };
-}
-async function storeSignature(walletClient, publicClient, signatureStore, signature) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareStoreSignature(signatureStore, account, signature);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function signTermsMessage(walletClient, publicClient, signatureStore) {
-  const account = walletClient.account;
-  if (!account) throw new Error("Wallet client has no account");
-  const message = await publicClient.readContract({
-    address: signatureStore,
-    abi: SignatureStoreABI,
-    functionName: "getCurrentVersionMessage"
-  });
-  return walletClient.signMessage({
-    account,
-    message
-  });
-}
-async function hasSignedCurrentVersion(publicClient, signatureStore, user) {
-  return await publicClient.readContract({
-    address: signatureStore,
-    abi: SignatureStoreABI,
-    functionName: "hasCurrentVersionSignature",
-    args: [user]
-  });
-}
-async function getCurrentMessage(publicClient, signatureStore) {
-  return await publicClient.readContract({
-    address: signatureStore,
-    abi: SignatureStoreABI,
-    functionName: "getCurrentVersionMessage"
-  });
-}
-
-// src/actions/admin.ts
-var admin_exports = {};
-__export(admin_exports, {
-  grantRole: () => grantRole,
-  prepareGrantRole: () => prepareGrantRole,
-  prepareRevokeRole: () => prepareRevokeRole,
-  revokeRole: () => revokeRole
-});
-function prepareGrantRole(symmioDiamond, account, role, grantee) {
-  validateAddress(grantee, "grantee");
-  const data = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "grantRole",
-    args: [grantee, role]
-  });
-  return {
-    functionName: "grantRole",
-    args: [grantee, role],
-    config: { account, to: symmioDiamond, data, value: 0n }
-  };
-}
-function prepareRevokeRole(symmioDiamond, account, role, revokee) {
-  validateAddress(revokee, "revokee");
-  const data = viem.encodeFunctionData({
-    abi: SymmioDiamondABI,
-    functionName: "revokeRole",
-    args: [revokee, role]
-  });
-  return {
-    functionName: "revokeRole",
-    args: [revokee, role],
-    config: { account, to: symmioDiamond, data, value: 0n }
-  };
-}
-async function grantRole(walletClient, publicClient, symmioDiamond, role, grantee) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareGrantRole(symmioDiamond, account, role, grantee);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
-async function revokeRole(walletClient, publicClient, symmioDiamond, role, revokee) {
-  const account = walletClient.account?.address;
-  if (!account) throw new Error("Wallet client has no account");
-  const prepared = prepareRevokeRole(symmioDiamond, account, role, revokee);
-  const gas = await publicClient.estimateGas(prepared.config);
-  return walletClient.sendTransaction({
-    ...prepared.config,
-    gas: calculateGasMargin(gas),
-    chain: walletClient.chain
-  });
-}
+// src/abis/MuonVerifier.ts
+var MuonVerifierABI = [
+  {
+    name: "addSignatureKey",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "publicKey", type: "address" },
+      { name: "nodeId", type: "bytes32" }
+    ],
+    outputs: []
+  },
+  {
+    name: "removeSignatureKey",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "publicKey", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "rotateSignatureKey",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "oldKey", type: "address" },
+      { name: "newKey", type: "address" }
+    ],
+    outputs: []
+  },
+  {
+    name: "isValidKey",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "publicKey", type: "address" }],
+    outputs: [{ name: "valid", type: "bool" }]
+  },
+  {
+    name: "getActiveKeys",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "keys", type: "address[]" }]
+  }
+];
 
-// src/actions/instant.ts
-var instant_exports = {};
-__export(instant_exports, {
-  cancelInstantClose: () => cancelInstantClose,
-  createSiweMessage: () => createSiweMessage,
-  getNonce: () => getNonce,
-  getOpenInstantCloses: () => getOpenInstantCloses,
-  instantClose: () => instantClose,
-  instantOpen: () => instantOpen,
-  login: () => login
-});
-function getHedgerBaseUrl(chainId) {
-  const baseUrl = HEDGER_BASE_URLS[chainId];
-  if (!baseUrl) {
-    throw new Error(`No hedger base URL configured for chain ${chainId}.`);
+// src/abis/SignatureStore.ts
+var SignatureStoreABI = [
+  {
+    name: "storeSignatureForCurrentVersion",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "signature", type: "bytes" }],
+    outputs: []
+  },
+  {
+    name: "hasCurrentVersionSignature",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ name: "hasSigned", type: "bool" }]
+  },
+  {
+    name: "getSignature",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "version", type: "uint256" },
+      { name: "user", type: "address" }
+    ],
+    outputs: [{ name: "signature", type: "bytes" }]
+  },
+  {
+    name: "getCurrentVersionMessage",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "message", type: "string" }]
+  },
+  {
+    name: "getCurrentVersion",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "version", type: "uint256" }]
   }
-  return baseUrl;
-}
-function createSiweMessage(params) {
-  const version = params.version ?? "1";
-  const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const expirationTime = new Date(
-    Date.now() + 30 * 24 * 60 * 60 * 1e3
-  ).toISOString();
-  const message = [
-    `${params.domain} wants you to sign in with your Ethereum account:`,
-    params.address,
-    "",
-    params.statement,
-    "",
-    `URI: ${params.uri}`,
-    `Version: ${version}`,
-    `Chain ID: ${params.chainId}`,
-    `Nonce: ${params.nonce}`,
-    `Issued At: ${issuedAt}`,
-    `Expiration Time: ${expirationTime}`
-  ].join("\n");
-  return { message, issuedAt, expirationTime };
-}
-async function getNonce(chainId, subAccount) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL(`nonce/${subAccount}`, hedgerBaseUrl).href;
-  const response = await fetch(url);
-  if (!response.ok) {
-    throw new Error(`Failed to fetch nonce: ${response.statusText}`);
+];
+
+// src/abis/ERC20.ts
+var ERC20ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "remaining", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "balance", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "decimals", type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "symbol", type: "string" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "supply", type: "uint256" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  },
+  {
+    name: "mint",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
   }
-  const data = await response.json();
-  return data.nonce;
+];
+
+// src/constants/chains.ts
+var SupportedChainId = /* @__PURE__ */ ((SupportedChainId2) => {
+  SupportedChainId2[SupportedChainId2["ARBITRUM"] = 42161] = "ARBITRUM";
+  SupportedChainId2[SupportedChainId2["BASE"] = 8453] = "BASE";
+  SupportedChainId2[SupportedChainId2["BSC"] = 56] = "BSC";
+  SupportedChainId2[SupportedChainId2["POLYGON"] = 137] = "POLYGON";
+  SupportedChainId2[SupportedChainId2["MAINNET"] = 1] = "MAINNET";
+  return SupportedChainId2;
+})(SupportedChainId || {});
+var V3_CHAIN_IDS = [
+  42161 /* ARBITRUM */,
+  8453 /* BASE */
+];
+var FALLBACK_CHAIN_ID = 42161 /* ARBITRUM */;
+var CHAIN_NAMES = {
+  [42161 /* ARBITRUM */]: "Arbitrum One",
+  [8453 /* BASE */]: "Base",
+  [56 /* BSC */]: "BNB Chain",
+  [137 /* POLYGON */]: "Polygon",
+  [1 /* MAINNET */]: "Ethereum"
+};
+
+// src/constants/addresses.ts
+var MULTI_ACCOUNT_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x6273242a7E88b3De90822b31648C212215caaFE4",
+  [8453 /* BASE */]: "0xE43166cE17d3511B09438a359dAa53513225101D"
+};
+var SYMMIO_DIAMOND_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x8F06459f184553e5d04F07F868720BDaCAB39395",
+  [8453 /* BASE */]: "0x91Cf2D8Ed503EC52768999aA6D8DBeA6e52dbe43"
+};
+var COLLATERAL_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  [8453 /* BASE */]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+};
+var CLEARING_HOUSE_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x0000000000000000000000000000000000000000",
+  [8453 /* BASE */]: "0x0000000000000000000000000000000000000000"
+};
+var SIGNATURE_STORE_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x94eEa58De1C8945c342dB4bE9670301638E403e2"
+};
+var DEFAULT_PARTY_B_ADDRESS = {
+  [42161 /* ARBITRUM */]: "0x00c069d68bc7420740460DBC3cc3fFF9b3742421",
+  [8453 /* BASE */]: "0x1EcAbF0Eba136920677C9575FAccee36f30592cf"
+};
+var COLLATERAL_DECIMALS = {
+  [42161 /* ARBITRUM */]: 6,
+  [8453 /* BASE */]: 6
+};
+function getAddress(addressMap, chainId, name) {
+  const addr = addressMap[chainId];
+  if (!addr || addr === "0x0000000000000000000000000000000000000000") {
+    throw new Error(`${name} address not configured for chain ${chainId}`);
+  }
+  return addr;
 }
-async function login(chainId, params) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL("login", hedgerBaseUrl).href;
-  const body = {
-    account_address: params.accountAddress,
-    expiration_time: params.expirationTime,
-    issued_at: params.issuedAt,
-    signature: params.signature,
-    nonce: params.nonce
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Login failed: ${response.statusText}`
-    );
+
+// src/constants/selectors.ts
+var SEND_QUOTE_WITH_AFFILIATE_SELECTOR = "0x40f1310c";
+var CLOSE_QUOTE_SELECTOR = "0x501e891f";
+var ALL_TRADING_SELECTORS = [
+  SEND_QUOTE_WITH_AFFILIATE_SELECTOR,
+  CLOSE_QUOTE_SELECTOR
+];
+
+// src/constants/defaults.ts
+var MARKET_ORDER_DEADLINE = 300n;
+var LIMIT_ORDER_DEADLINE = 311040120n;
+var MARKET_PRICE_COEFFICIENT = 1.01;
+var MAX_LEVERAGE = 50;
+var DEFAULT_PRECISION = 2;
+var GAS_MARGIN_PERCENTAGE = 20n;
+var STANDARD_WITHDRAW_COOLDOWN = 43200;
+var MUON_BASE_URLS = [
+  "https://muon-oracle1.rasa.capital/v1/",
+  "https://muon-oracle2.rasa.capital/v1/",
+  "https://muon-oracle3.rasa.capital/v1/",
+  "https://muon-oracle4.rasa.capital/v1/"
+];
+var MUON_APP_NAME = "symmio";
+var MUON_REQUEST_TIMEOUT = 15e3;
+var HEDGER_BASE_URLS = {
+  [42161 /* ARBITRUM */]: "https://www.perps-streaming.com/v1/42161a/0x6273242a7E88b3De90822b31648C212215caaFE4",
+  [8453 /* BASE */]: "https://www.perps-streaming.com/v1/8453a/0x6273242a7E88b3De90822b31648C212215caaFE4"
+};
+var SymmioSDKError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "SymmioSDKError";
   }
-  const data = await response.json();
-  if (!data.access_token) {
-    throw new Error("No access token received");
+};
+function validateAddress(address, name) {
+  if (!viem.isAddress(address)) {
+    throw new SymmioSDKError(
+      `Invalid ${name} address: ${address}`,
+      "INVALID_ADDRESS"
+    );
   }
-  return {
-    accessToken: data.access_token,
-    expirationTime: params.expirationTime,
-    issuedAt: params.issuedAt
-  };
+  return address;
 }
-async function instantOpen(chainId, params, accessToken) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL("instant_open", hedgerBaseUrl).href;
-  const body = {
-    symbolId: params.symbolId,
-    positionType: params.positionType,
-    orderType: params.orderType,
-    price: params.price,
-    quantity: params.quantity,
-    cva: params.cva,
-    lf: params.lf,
-    partyAmm: params.partyAmm,
-    partyBmm: params.partyBmm,
-    maxFundingRate: params.maxFundingRate,
-    deadline: params.deadline
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${accessToken}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Instant open failed: ${response.statusText}`
+function validateAmount(amount, name) {
+  if (amount <= 0n) {
+    throw new SymmioSDKError(
+      `${name} must be a positive amount, got ${amount}`,
+      "INVALID_AMOUNT"
     );
   }
-  return response.json();
 }
-async function instantClose(chainId, params, accessToken) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL("instant_close", hedgerBaseUrl).href;
-  const body = {
-    quote_id: params.quoteId,
-    quantity_to_close: params.quantityToClose,
-    close_price: params.closePrice
-  };
-  const response = await fetch(url, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${accessToken}`
-    },
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Instant close failed: ${response.statusText}`
+function validateChainId(chainId, supportedChains) {
+  if (!supportedChains.includes(chainId)) {
+    throw new SymmioSDKError(
+      `Chain ${chainId} is not supported. Supported: ${supportedChains.join(", ")}`,
+      "UNSUPPORTED_CHAIN"
     );
   }
-  return response.json();
 }
-async function cancelInstantClose(chainId, quoteId, accessToken) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL(`instant_close/${quoteId}`, hedgerBaseUrl).href;
-  const response = await fetch(url, {
-    method: "DELETE",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${accessToken}`
-    }
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Cancel instant close failed: ${response.statusText}`
+function validateDeadline(deadline) {
+  const now = BigInt(Math.floor(Date.now() / 1e3));
+  if (deadline <= now) {
+    throw new SymmioSDKError(
+      `Deadline ${deadline} is in the past (current: ${now})`,
+      "EXPIRED_DEADLINE"
     );
   }
 }
-async function getOpenInstantCloses(chainId, account, accessToken) {
-  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
-  const url = new URL(`instant_close/${account}`, hedgerBaseUrl).href;
-  const response = await fetch(url, {
-    headers: {
-      Authorization: `Bearer ${accessToken}`
-    }
-  });
-  if (!response.ok) {
-    const errorData = await response.json().catch(() => null);
-    throw new Error(
-      errorData?.error_message ?? `Failed to fetch instant closes: ${response.statusText}`
+function validateQuantity(quantity) {
+  if (quantity <= 0n) {
+    throw new SymmioSDKError(
+      `Quantity must be positive, got ${quantity}`,
+      "INVALID_QUANTITY"
     );
   }
-  return response.json();
 }
 
-// src/actions/stats.ts
-var stats_exports = {};
-__export(stats_exports, {
-  calculateAvailableForOrder: () => calculateAvailableForOrder,
-  getPartyAStats: () => getPartyAStats
-});
-async function getPartyAStats(publicClient, symmioDiamond, partyA) {
-  const result = await publicClient.readContract({
-    address: symmioDiamond,
-    abi: SymmioDiamondABI,
-    functionName: "partyAStats",
-    args: [partyA]
-  });
+// src/clients/muon.ts
+function parseSchnorrSign(sigs) {
   return {
-    collateralBalance: result[1],
-    allocatedBalance: result[2],
-    availableBalance: result[3],
-    lockedCVA: result[4],
-    lockedLF: result[5],
-    lockedPartyAMM: result[6],
-    lockedPartyBMM: result[7],
-    pendingLockedCVA: result[8],
-    pendingLockedLF: result[9],
-    pendingLockedPartyAMM: result[10],
-    pendingLockedPartyBMM: result[11],
-    positionsCount: Number(result[12]),
-    pendingCount: Number(result[13]),
-    nonces: 0
+    signature: BigInt(sigs.signature),
+    owner: sigs.owner,
+    nonce: sigs.nonce
   };
 }
-function calculateAvailableForOrder(stats, upnl) {
-  const {
-    allocatedBalance,
-    lockedCVA,
-    lockedLF,
-    lockedPartyAMM,
-    pendingLockedCVA,
-    pendingLockedLF,
-    pendingLockedPartyAMM
-  } = stats;
-  const totalPendingLocked = pendingLockedCVA + pendingLockedLF + pendingLockedPartyAMM;
-  if (upnl >= 0n) {
-    const totalLocked = lockedCVA + lockedLF + lockedPartyAMM;
-    return allocatedBalance + upnl - totalLocked - totalPendingLocked;
+function parseSingleUpnlSig(result) {
+  const data = result["result"];
+  if (!data) {
+    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
   }
-  const absUpnl = -upnl;
-  const consideringMm = absUpnl > lockedPartyAMM ? absUpnl : lockedPartyAMM;
-  return allocatedBalance - lockedCVA - lockedLF - totalPendingLocked - consideringMm;
+  const sigData = data["data"];
+  const signParams = sigData?.["signParams"] ?? data["signParams"];
+  const signatures = sigData?.["signatures"] ?? data["signatures"];
+  return {
+    reqId: signParams["reqId"],
+    timestamp: BigInt(signParams["timestamp"]),
+    upnl: BigInt(signParams["upnl"]),
+    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
+    sigs: parseSchnorrSign(
+      signParams["sigs"] ?? signatures?.[1]
+    )
+  };
 }
-
-// src/client.ts
-var SymmioSDK = class {
-  chainId;
-  muon;
-  _publicClient;
-  _walletClient;
-  _multiAccount;
-  _symmioDiamond;
-  _collateral;
-  _clearingHouse;
-  _signatureStore;
-  constructor(options) {
-    this.chainId = options.chainId;
-    this._publicClient = options.publicClient;
-    this._walletClient = options.walletClient;
-    const cfg = options.config ?? {};
-    this._multiAccount = cfg.multiAccountAddress ?? getAddress(MULTI_ACCOUNT_ADDRESS, this.chainId, "MultiAccount");
-    this._symmioDiamond = cfg.symmioDiamondAddress ?? getAddress(SYMMIO_DIAMOND_ADDRESS, this.chainId, "SymmioDiamond");
-    this._collateral = cfg.collateralAddress ?? getAddress(COLLATERAL_ADDRESS, this.chainId, "Collateral");
-    try {
-      this._clearingHouse = cfg.clearingHouseAddress ?? getAddress(CLEARING_HOUSE_ADDRESS, this.chainId, "ClearingHouse");
-    } catch {
-    }
-    try {
-      this._signatureStore = cfg.signatureStoreAddress ?? getAddress(SIGNATURE_STORE_ADDRESS, this.chainId, "SignatureStore");
-    } catch {
-    }
-    this.muon = new MuonClient({
-      baseUrls: cfg.muonBaseUrls ?? MUON_BASE_URLS,
-      appName: cfg.muonAppName ?? MUON_APP_NAME
-    });
+function parseSingleUpnlAndPriceSig(result) {
+  const data = result["result"];
+  if (!data) {
+    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
   }
-  get walletClient() {
-    return this._walletClient ?? null;
+  const sigData = data["data"];
+  const signParams = sigData?.["signParams"] ?? data["signParams"];
+  const signatures = sigData?.["signatures"] ?? data["signatures"];
+  return {
+    reqId: signParams["reqId"],
+    timestamp: BigInt(signParams["timestamp"]),
+    upnl: BigInt(signParams["upnl"]),
+    price: BigInt(signParams["price"]),
+    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
+    sigs: parseSchnorrSign(
+      signParams["sigs"] ?? signatures?.[1]
+    )
+  };
+}
+function parseBatchSig(result) {
+  const data = result["result"];
+  if (!data) {
+    throw new SymmioSDKError("Invalid Muon response: missing result", "MUON_PARSE_ERROR");
   }
-  get isWriteReady() {
-    return !!this._walletClient;
+  const sigData = data["data"];
+  const signParams = sigData?.["signParams"] ?? data["signParams"];
+  const signatures = sigData?.["signatures"] ?? data["signatures"];
+  return {
+    reqId: signParams["reqId"],
+    timestamp: BigInt(signParams["timestamp"]),
+    upnl: BigInt(signParams["upnl"]),
+    prices: signParams["prices"].map((p) => BigInt(p)),
+    symbolIds: signParams["symbolIds"].map((s) => BigInt(s)),
+    gatewaySignature: signatures?.[0]?.["signature"] ?? "0x",
+    sigs: parseSchnorrSign(
+      signParams["sigs"] ?? signatures?.[1]
+    )
+  };
+}
+var MuonClient = class {
+  baseUrls;
+  appName;
+  timeout;
+  constructor(config) {
+    this.baseUrls = config?.baseUrls ?? MUON_BASE_URLS;
+    this.appName = config?.appName ?? MUON_APP_NAME;
+    this.timeout = config?.timeout ?? MUON_REQUEST_TIMEOUT;
   }
-  requireWalletClient() {
-    if (!this._walletClient) {
-      throw new Error("WalletClient is required for write operations");
+  /**
+   * Sends a request to Muon, trying each base URL in order until one succeeds.
+   */
+  async sendRequest(method, params) {
+    let lastError = null;
+    for (const baseUrl of this.baseUrls) {
+      try {
+        const searchParams = new URLSearchParams({
+          app: this.appName,
+          method
+        });
+        for (const [key, value] of Object.entries(params)) {
+          searchParams.set(`params[${key}]`, value);
+        }
+        const url = `${baseUrl}?${searchParams.toString()}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        const response = await fetch(url, { signal: controller.signal });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const json = await response.json();
+        if (json["error"]) {
+          throw new Error(`Muon error: ${JSON.stringify(json["error"])}`);
+        }
+        return json;
+      } catch (err) {
+        lastError = err instanceof Error ? err : new Error(String(err));
+      }
     }
-    return this._walletClient;
-  }
-  // ─── Contract Addresses ────────────────────────────────────────
-  get addresses() {
-    return {
-      multiAccount: this._multiAccount,
-      symmioDiamond: this._symmioDiamond,
-      collateral: this._collateral,
-      clearingHouse: this._clearingHouse,
-      signatureStore: this._signatureStore
-    };
-  }
-  // ─── Account Module (MultiAccount) ─────────────────────────────
-  get account() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Creates a new account. */
-      addAccount: (name) => addAccount(this.requireWalletClient(), pc, ma, name),
-      /** Edits an account's name. */
-      editName: (accountAddress, name) => editAccountName(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        accountAddress,
-        name
-      ),
-      /** Gets all accounts for a user (paginated). */
-      getAll: (user, start, size) => getAccounts(pc, ma, user, start, size),
-      /** Gets the number of accounts for a user. */
-      getCount: (user) => getAccountsLength(pc, ma, user),
-      /** Gets the owner of an account. */
-      getOwner: (accountAddress) => getOwner(pc, ma, accountAddress)
-    };
-  }
-  // ─── Deposit Module (MultiAccount) ─────────────────────────────
-  get deposit() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Standard deposit to an account. */
-      standard: (params) => deposit(this.requireWalletClient(), pc, ma, params),
-      /** Deposit and allocate in a single transaction. */
-      depositAndAllocate: (params) => depositAndAllocate(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        params
-      )
-    };
-  }
-  // ─── Withdraw Module (MultiAccount) ────────────────────────────
-  get withdraw() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Withdraws collateral from an account. */
-      withdraw: (params) => withdraw(this.requireWalletClient(), pc, ma, params)
-    };
-  }
-  // ─── Allocate / Deallocate Module (via _call proxy) ────────────
-  get collateral() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Allocate collateral to a trading account. */
-      allocate: (subAccount, params) => allocate(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        params
-      ),
-      /** Deallocate collateral (requires Muon signature). */
-      deallocate: (subAccount, params) => deallocate(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        params
-      ),
-      /** Transfer funds to recipient's allocated balance. */
-      internalTransfer: (subAccount, params) => internalTransfer(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        params
-      )
-    };
-  }
-  // ─── Trade Module ──────────────────────────────────────────────
-  get trade() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Opens a position via sendQuoteWithAffiliate. */
-      sendQuote: (subAccount, params) => sendQuote(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        params
-      ),
-      /** Close a position. */
-      closePosition: (subAccount, params) => closePosition(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        params
-      ),
-      /** Cancel a pending quote. */
-      cancelQuote: (subAccount, quoteId) => cancelQuote(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        quoteId
-      ),
-      /** Cancel a pending close request. */
-      cancelCloseRequest: (subAccount, quoteId) => cancelCloseRequest(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        quoteId
-      ),
-      /** Force cancel a quote. */
-      forceCancelQuote: (subAccount, quoteId) => forceCancelQuote(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        quoteId
-      ),
-      /** Force cancel a close request. */
-      forceCancelCloseRequest: (subAccount, quoteId) => forceCancelCloseRequest(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        subAccount,
-        quoteId
-      )
-    };
-  }
-  // ─── Approval Module ───────────────────────────────────────────
-  get approval() {
-    const pc = this._publicClient;
-    const collateral = this._collateral;
-    const ma = this._multiAccount;
-    return {
-      /** Approve the MultiAccount contract to spend collateral. */
-      approveCollateral: (amount) => approve(
-        this.requireWalletClient(),
-        pc,
-        collateral,
-        ma,
-        amount
-      ),
-      /** Approve any spender for any token. */
-      approve: (token, spender, amount) => approve(
-        this.requireWalletClient(),
-        pc,
-        token,
-        spender,
-        amount
-      ),
-      /** Get current allowance. */
-      getAllowance: (token, owner, spender) => getAllowance(pc, token, owner, spender),
-      /** Get token balance. */
-      getBalance: (token, account) => getBalance(pc, token, account),
-      /** Get approval state for a required amount. */
-      getState: (token, owner, spender, requiredAmount) => getApprovalState(pc, token, owner, spender, requiredAmount)
-    };
-  }
-  // ─── Delegation Module ─────────────────────────────────────────
-  get delegation() {
-    const pc = this._publicClient;
-    const ma = this._multiAccount;
-    return {
-      /** Delegate access to selectors. */
-      delegateAccess: (params) => delegateAccess(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        params
-      ),
-      /** Propose to revoke delegated access (starts cooldown). */
-      proposeRevoke: (params) => proposeRevoke(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        params
-      ),
-      /** Revoke delegated access (after cooldown). */
-      revokeAccess: (params) => revokeAccess(
-        this.requireWalletClient(),
-        pc,
-        ma,
-        params
-      ),
-      /** Reads whether a selector is delegated to a target for a sub-account. */
-      hasAccess: (params) => hasDelegatedAccess(pc, ma, params)
-    };
-  }
-  // ─── Signature Module ──────────────────────────────────────────
-  get signature() {
-    const pc = this._publicClient;
-    const ss = this._signatureStore;
-    return {
-      signTerms: () => {
-        if (!ss) throw new Error("SignatureStore not configured for this chain");
-        return signTermsMessage(this.requireWalletClient(), pc, ss);
-      },
-      storeSignature: (sig) => {
-        if (!ss) throw new Error("SignatureStore not configured for this chain");
-        return storeSignature(
-          this.requireWalletClient(),
-          pc,
-          ss,
-          sig
-        );
-      },
-      hasSigned: (user) => {
-        if (!ss) throw new Error("SignatureStore not configured for this chain");
-        return hasSignedCurrentVersion(pc, ss, user);
-      },
-      getMessage: () => {
-        if (!ss) throw new Error("SignatureStore not configured for this chain");
-        return getCurrentMessage(pc, ss);
-      }
-    };
-  }
-  // ─── Admin Module ──────────────────────────────────────────────
-  get admin() {
-    const pc = this._publicClient;
-    const sd = this._symmioDiamond;
-    return {
-      grantRole: (role, grantee) => grantRole(this.requireWalletClient(), pc, sd, role, grantee),
-      revokeRole: (role, revokee) => revokeRole(this.requireWalletClient(), pc, sd, role, revokee)
-    };
-  }
-  // ─── Instant Trading Module ──────────────────────────────────
-  get instant() {
-    return {
-      /** Creates a SIWE message for instant trading authentication. */
-      createSiweMessage: (params) => createSiweMessage(params),
-      /** Fetches a nonce from the hedger for SIWE authentication. */
-      getNonce: (subAccount) => getNonce(this.chainId, subAccount),
-      /** Exchanges a signed SIWE message for an access token. */
-      login: (params) => login(this.chainId, params),
-      /** Opens a position instantly via the hedger (off-chain). */
-      open: (params, accessToken) => instantOpen(this.chainId, params, accessToken),
-      /** Closes a position instantly via the hedger (off-chain). */
-      close: (params, accessToken) => instantClose(this.chainId, params, accessToken),
-      /** Cancels a pending instant close request. */
-      cancelClose: (quoteId, accessToken) => cancelInstantClose(this.chainId, quoteId, accessToken),
-      /** Fetches the list of open instant close requests for an account. */
-      getOpenCloses: (account, accessToken) => getOpenInstantCloses(this.chainId, account, accessToken)
-    };
+    throw new SymmioSDKError(
+      `All Muon nodes failed. Last error: ${lastError?.message}`,
+      "MUON_REQUEST_FAILED"
+    );
   }
-  // ─── Stats Module ───────────────────────────────────────────
-  get stats() {
-    const pc = this._publicClient;
-    const sd = this._symmioDiamond;
-    return {
-      /** Reads partyA statistics (balances, locks) from the Diamond contract. */
-      getPartyAStats: (partyA) => getPartyAStats(pc, sd, partyA),
-      /** Calculates available margin for placing orders given uPNL. */
-      calculateAvailableForOrder: (stats, upnl) => calculateAvailableForOrder(stats, upnl)
-    };
+  /**
+   * Gets a UPnL + Price signature for opening a position (sendQuote).
+   */
+  async getQuoteSig(params) {
+    const result = await this.sendRequest("uPnl_A_withSymbolPrice", {
+      partyA: params.partyA,
+      chainId: params.chainId.toString(),
+      symmio: params.symmioAddress,
+      symbolId: params.symbolId.toString()
+    });
+    return parseSingleUpnlAndPriceSig(result);
   }
-  // ─── Muon Signatures ──────────────────────────────────────────
-  async getQuoteSig(partyA, symbolId) {
-    return this.muon.getQuoteSig({
-      partyA,
-      chainId: this.chainId,
-      symmioAddress: this._symmioDiamond,
-      symbolId
+  /**
+   * Gets a UPnL signature for deallocating funds.
+   * v0.8.5: Now includes pendingBalance for safe deallocate.
+   */
+  async getDeallocateSig(params) {
+    const result = await this.sendRequest("uPnl_A", {
+      partyA: params.partyA,
+      chainId: params.chainId.toString(),
+      symmio: params.symmioAddress
     });
+    return parseSingleUpnlSig(result);
   }
-  async getDeallocateSig(partyA) {
-    return this.muon.getDeallocateSig({
-      partyA,
-      chainId: this.chainId,
-      symmioAddress: this._symmioDiamond
+  /**
+   * Gets a batch signature for multiple positions (v0.8.5).
+   * Single signature covers multiple symbol prices for batch open/close.
+   */
+  async getBatchSig(params) {
+    const result = await this.sendRequest("uPnl_A_withSymbolPrices", {
+      partyA: params.partyA,
+      chainId: params.chainId.toString(),
+      symmio: params.symmioAddress,
+      symbolIds: params.symbolIds.join(",")
     });
+    return parseBatchSig(result);
   }
 };
 
-// src/types/common.ts
-var PositionType = /* @__PURE__ */ ((PositionType2) => {
-  PositionType2[PositionType2["LONG"] = 0] = "LONG";
-  PositionType2[PositionType2["SHORT"] = 1] = "SHORT";
-  return PositionType2;
-})(PositionType || {});
-var OrderType = /* @__PURE__ */ ((OrderType2) => {
-  OrderType2[OrderType2["LIMIT"] = 0] = "LIMIT";
-  OrderType2[OrderType2["MARKET"] = 1] = "MARKET";
-  return OrderType2;
-})(OrderType || {});
-var QuoteStatus = /* @__PURE__ */ ((QuoteStatus2) => {
-  QuoteStatus2[QuoteStatus2["PENDING"] = 0] = "PENDING";
-  QuoteStatus2[QuoteStatus2["LOCKED"] = 1] = "LOCKED";
-  QuoteStatus2[QuoteStatus2["CANCEL_PENDING"] = 2] = "CANCEL_PENDING";
-  QuoteStatus2[QuoteStatus2["CANCELED"] = 3] = "CANCELED";
-  QuoteStatus2[QuoteStatus2["OPENED"] = 4] = "OPENED";
-  QuoteStatus2[QuoteStatus2["CLOSE_PENDING"] = 5] = "CLOSE_PENDING";
-  QuoteStatus2[QuoteStatus2["CANCEL_CLOSE_PENDING"] = 6] = "CANCEL_CLOSE_PENDING";
-  QuoteStatus2[QuoteStatus2["CLOSED"] = 7] = "CLOSED";
-  QuoteStatus2[QuoteStatus2["LIQUIDATED"] = 8] = "LIQUIDATED";
-  QuoteStatus2[QuoteStatus2["EXPIRED"] = 9] = "EXPIRED";
-  return QuoteStatus2;
-})(QuoteStatus || {});
-var LiquidationStatus = /* @__PURE__ */ ((LiquidationStatus2) => {
-  LiquidationStatus2[LiquidationStatus2["NONE"] = 0] = "NONE";
-  LiquidationStatus2[LiquidationStatus2["PENDING"] = 1] = "PENDING";
-  LiquidationStatus2[LiquidationStatus2["ACTIVE"] = 2] = "ACTIVE";
-  LiquidationStatus2[LiquidationStatus2["COMPLETED"] = 3] = "COMPLETED";
-  return LiquidationStatus2;
-})(LiquidationStatus || {});
-var SoftLiquidationLevel = /* @__PURE__ */ ((SoftLiquidationLevel2) => {
-  SoftLiquidationLevel2[SoftLiquidationLevel2["NONE"] = 0] = "NONE";
-  SoftLiquidationLevel2[SoftLiquidationLevel2["WARNING"] = 1] = "WARNING";
-  SoftLiquidationLevel2[SoftLiquidationLevel2["CRITICAL"] = 2] = "CRITICAL";
-  SoftLiquidationLevel2[SoftLiquidationLevel2["EMERGENCY"] = 3] = "EMERGENCY";
-  return SoftLiquidationLevel2;
-})(SoftLiquidationLevel || {});
+// src/actions/account.ts
+var account_exports = {};
+__export(account_exports, {
+  addAccount: () => addAccount,
+  editAccountName: () => editAccountName,
+  getAccounts: () => getAccounts,
+  getAccountsLength: () => getAccountsLength,
+  getOwner: () => getOwner,
+  prepareAddAccount: () => prepareAddAccount,
+  prepareEditAccountName: () => prepareEditAccountName
+});
 
-// src/types/affiliate.ts
-var AffiliateFeeLevel = /* @__PURE__ */ ((AffiliateFeeLevel2) => {
-  AffiliateFeeLevel2[AffiliateFeeLevel2["USER_SYMBOL"] = 0] = "USER_SYMBOL";
-  AffiliateFeeLevel2[AffiliateFeeLevel2["USER_DEFAULT"] = 1] = "USER_DEFAULT";
-  AffiliateFeeLevel2[AffiliateFeeLevel2["SYMBOL"] = 2] = "SYMBOL";
-  AffiliateFeeLevel2[AffiliateFeeLevel2["AFFILIATE_DEFAULT"] = 3] = "AFFILIATE_DEFAULT";
-  return AffiliateFeeLevel2;
-})(AffiliateFeeLevel || {});
+// src/utils/gas.ts
+function calculateGasMargin(estimatedGas) {
+  return estimatedGas * (100n + GAS_MARGIN_PERCENTAGE) / 100n;
+}
 
-// src/types/clearingHouse.ts
-var ClearingHouseLiquidationStatus = /* @__PURE__ */ ((ClearingHouseLiquidationStatus2) => {
-  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["INITIATED"] = 0] = "INITIATED";
-  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["DEALLOCATED"] = 1] = "DEALLOCATED";
-  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["POSITIONS_CLOSED"] = 2] = "POSITIONS_CLOSED";
-  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["SETTLED"] = 3] = "SETTLED";
-  ClearingHouseLiquidationStatus2[ClearingHouseLiquidationStatus2["COMPLETED"] = 4] = "COMPLETED";
-  return ClearingHouseLiquidationStatus2;
-})(ClearingHouseLiquidationStatus || {});
+// src/actions/account.ts
+function prepareAddAccount(multiAccount, account, name) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "addAccount",
+    args: [name]
+  });
+  return {
+    functionName: "addAccount",
+    args: [name],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+function prepareEditAccountName(multiAccount, account, accountAddress, name) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "editAccountName",
+    args: [accountAddress, name]
+  });
+  return {
+    functionName: "editAccountName",
+    args: [accountAddress, name],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+async function addAccount(walletClient, publicClient, multiAccount, name) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareAddAccount(multiAccount, account, name);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function editAccountName(walletClient, publicClient, multiAccount, accountAddress, name) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareEditAccountName(multiAccount, account, accountAddress, name);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function getAccounts(publicClient, multiAccount, user, start = 0, size = 100) {
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "getAccounts",
+    args: [user, BigInt(start), BigInt(size)]
+  });
+  return result;
+}
+async function getAccountsLength(publicClient, multiAccount, user) {
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "getAccountsLength",
+    args: [user]
+  });
+  return Number(result);
+}
+async function getOwner(publicClient, multiAccount, accountAddress) {
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "owners",
+    args: [accountAddress]
+  });
+  return result;
+}
 
-// src/types/instant.ts
-var InstantCloseStatus = /* @__PURE__ */ ((InstantCloseStatus2) => {
-  InstantCloseStatus2[InstantCloseStatus2["STARTED"] = 0] = "STARTED";
-  InstantCloseStatus2[InstantCloseStatus2["PROCESSING"] = 1] = "PROCESSING";
-  InstantCloseStatus2[InstantCloseStatus2["FAILED"] = 2] = "FAILED";
-  InstantCloseStatus2[InstantCloseStatus2["FINISHED"] = 3] = "FINISHED";
-  return InstantCloseStatus2;
-})(InstantCloseStatus || {});
+// src/actions/deposit.ts
+var deposit_exports = {};
+__export(deposit_exports, {
+  deposit: () => deposit,
+  depositAndAllocate: () => depositAndAllocate,
+  prepareDeposit: () => prepareDeposit,
+  prepareDepositAndAllocate: () => prepareDepositAndAllocate
+});
+function prepareDeposit(multiAccount, account, params) {
+  validateAmount(params.amount, "deposit amount");
+  validateAddress(params.account, "account");
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "depositForAccount",
+    args: [params.account, params.amount]
+  });
+  return {
+    functionName: "depositForAccount",
+    args: [params.account, params.amount],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+function prepareDepositAndAllocate(multiAccount, account, params) {
+  validateAmount(params.amount, "deposit amount");
+  validateAddress(params.account, "account");
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "depositAndAllocateForAccount",
+    args: [params.account, params.amount]
+  });
+  return {
+    functionName: "depositAndAllocateForAccount",
+    args: [params.account, params.amount],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+async function deposit(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareDeposit(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function depositAndAllocate(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareDepositAndAllocate(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
 
-// src/abis/ClearingHouse.ts
-var ClearingHouseABI = [
-  // ─── Liquidation Lifecycle ────────────────────────────────────
-  {
-    name: "initiateLiquidation",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "partyA", type: "address" },
-      { name: "partyB", type: "address" }
-    ],
-    outputs: [{ name: "liquidationId", type: "uint256" }]
-  },
-  {
-    name: "deallocateLiquidation",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "liquidationId", type: "uint256" }],
-    outputs: []
-  },
-  {
-    name: "closePositionsInLiquidation",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "liquidationId", type: "uint256" },
-      { name: "quoteIds", type: "uint256[]" },
-      { name: "closePrices", type: "uint256[]" }
-    ],
-    outputs: []
-  },
-  {
-    name: "distributeLiquidation",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "liquidationId", type: "uint256" }],
-    outputs: []
-  },
-  {
-    name: "settleLiquidation",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "liquidationId", type: "uint256" }],
-    outputs: []
-  },
-  // ─── Soft Liquidation (v0.8.5) ────────────────────────────────
-  {
-    name: "applySoftLiquidationPenalty",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "partyB", type: "address" },
-      { name: "level", type: "uint8" }
-    ],
-    outputs: []
-  },
-  {
-    name: "setSoftLiquidationThreshold",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "level", type: "uint8" },
-      { name: "ratio", type: "uint256" },
-      { name: "penalty", type: "uint256" }
-    ],
-    outputs: []
-  },
-  // ─── Auto-Takeover ────────────────────────────────────────────
-  {
-    name: "autoTakeover",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "liquidationId", type: "uint256" },
-      { name: "newPartyB", type: "address" }
-    ],
-    outputs: []
-  },
-  // ─── ADL Assurance ────────────────────────────────────────────
-  {
-    name: "depositADLAssurance",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "partyB", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  },
-  {
-    name: "slashADLAssurance",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "partyB", type: "address" }],
-    outputs: []
-  },
-  // ─── Insurance Vault ──────────────────────────────────────────
-  {
-    name: "setMaxLiquidatorProfit",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "maxProfit", type: "uint256" }],
-    outputs: []
-  },
-  {
-    name: "reimbursePartyB",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "partyB", type: "address" },
-      { name: "amount", type: "uint256" }
-    ],
-    outputs: []
-  },
-  // ─── View Functions ───────────────────────────────────────────
-  {
-    name: "getLiquidation",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "liquidationId", type: "uint256" }],
-    outputs: [
-      {
-        name: "liquidation",
-        type: "tuple",
-        components: [
-          { name: "id", type: "uint256" },
-          { name: "partyA", type: "address" },
-          { name: "partyB", type: "address" },
-          { name: "status", type: "uint8" },
-          { name: "deallocatedAmount", type: "uint256" },
-          { name: "settledAmount", type: "uint256" },
-          { name: "createdAt", type: "uint256" }
-        ]
-      }
+// src/actions/withdraw.ts
+var withdraw_exports = {};
+__export(withdraw_exports, {
+  prepareWithdraw: () => prepareWithdraw,
+  withdraw: () => withdraw
+});
+function prepareWithdraw(multiAccount, account, params) {
+  validateAmount(params.amount, "withdraw amount");
+  validateAddress(params.account, "account");
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount]
+  });
+  return {
+    functionName: "withdrawFromAccount",
+    args: [params.account, params.amount],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+async function withdraw(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareWithdraw(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/actions/allocate.ts
+var allocate_exports = {};
+__export(allocate_exports, {
+  allocate: () => allocate,
+  deallocate: () => deallocate,
+  internalTransfer: () => internalTransfer,
+  prepareAllocate: () => prepareAllocate,
+  prepareDeallocate: () => prepareDeallocate,
+  prepareInternalTransfer: () => prepareInternalTransfer
+});
+function encodeCall(abi, functionName, args) {
+  return viem.encodeFunctionData({
+    abi,
+    functionName,
+    args
+  });
+}
+function wrapInProxyCall(accountDiamondAbi, subAccount, callDatas) {
+  const data = viem.encodeFunctionData({
+    abi: accountDiamondAbi,
+    functionName: "_call",
+    args: [subAccount, callDatas]
+  });
+  return {
+    functionName: "_call",
+    args: [subAccount, callDatas],
+    data
+  };
+}
+
+// src/actions/allocate.ts
+function prepareAllocate(multiAccount, account, subAccount, params) {
+  validateAmount(params.amount, "allocate amount");
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "allocate",
+    args: [params.amount]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function prepareDeallocate(multiAccount, account, subAccount, params) {
+  validateAmount(params.amount, "deallocate amount");
+  const muonSig = {
+    reqId: params.upnlSig.reqId,
+    timestamp: params.upnlSig.timestamp,
+    upnl: params.upnlSig.upnl,
+    gatewaySignature: params.upnlSig.gatewaySignature,
+    sigs: {
+      signature: params.upnlSig.sigs.signature,
+      owner: params.upnlSig.sigs.owner,
+      nonce: params.upnlSig.sigs.nonce
+    }
+  };
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "deallocate",
+    args: [params.amount, muonSig]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function prepareInternalTransfer(multiAccount, account, subAccount, params) {
+  validateAmount(params.amount, "transfer amount");
+  validateAddress(params.recipient, "recipient");
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "internalTransfer",
+    args: [params.recipient, params.amount]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+async function allocate(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareAllocate(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function deallocate(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareDeallocate(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function internalTransfer(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareInternalTransfer(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/actions/trade.ts
+var trade_exports = {};
+__export(trade_exports, {
+  preparePairTrade: () => preparePairTrade,
+  prepareSendQuote: () => prepareSendQuote,
+  sendQuote: () => sendQuote
+});
+function buildUpnlSigTuple(sig) {
+  return {
+    reqId: sig.reqId,
+    timestamp: sig.timestamp,
+    upnl: sig.upnl,
+    price: sig.price,
+    gatewaySignature: sig.gatewaySignature,
+    sigs: {
+      signature: sig.sigs.signature,
+      owner: sig.sigs.owner,
+      nonce: sig.sigs.nonce
+    }
+  };
+}
+function prepareSendQuote(multiAccount, account, subAccount, params) {
+  validateQuantity(params.quantity);
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "sendQuoteWithAffiliate",
+    args: [
+      params.partyBsWhiteList,
+      BigInt(params.symbolId),
+      params.positionType,
+      params.orderType,
+      params.price,
+      params.quantity,
+      params.cva,
+      params.lf,
+      params.partyAmm,
+      params.partyBmm,
+      params.maxFundingRate,
+      params.deadline,
+      params.affiliate,
+      buildUpnlSigTuple(params.upnlSig)
     ]
-  },
-  // ─── Events ───────────────────────────────────────────────────
-  {
-    name: "LiquidationInitiated",
-    type: "event",
-    inputs: [
-      { name: "liquidationId", type: "uint256", indexed: true },
-      { name: "partyA", type: "address", indexed: true },
-      { name: "partyB", type: "address", indexed: true }
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function preparePairTrade(multiAccount, account, subAccount, longParams, shortParams) {
+  const longData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "sendQuoteWithAffiliate",
+    args: [
+      longParams.partyBsWhiteList,
+      BigInt(longParams.symbolId),
+      longParams.positionType,
+      longParams.orderType,
+      longParams.price,
+      longParams.quantity,
+      longParams.cva,
+      longParams.lf,
+      longParams.partyAmm,
+      longParams.partyBmm,
+      longParams.maxFundingRate,
+      longParams.deadline,
+      longParams.affiliate,
+      buildUpnlSigTuple(longParams.upnlSig)
+    ]
+  });
+  const shortData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "sendQuoteWithAffiliate",
+    args: [
+      shortParams.partyBsWhiteList,
+      BigInt(shortParams.symbolId),
+      shortParams.positionType,
+      shortParams.orderType,
+      shortParams.price,
+      shortParams.quantity,
+      shortParams.cva,
+      shortParams.lf,
+      shortParams.partyAmm,
+      shortParams.partyBmm,
+      shortParams.maxFundingRate,
+      shortParams.deadline,
+      shortParams.affiliate,
+      buildUpnlSigTuple(shortParams.upnlSig)
+    ]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [longData, shortData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+async function sendQuote(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareSendQuote(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/actions/close.ts
+var close_exports = {};
+__export(close_exports, {
+  closePosition: () => closePosition,
+  prepareClosePosition: () => prepareClosePosition,
+  preparePairClose: () => preparePairClose
+});
+function prepareClosePosition(multiAccount, account, subAccount, params) {
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "requestToClosePosition",
+    args: [
+      params.quoteId,
+      params.closePrice,
+      params.quantityToClose,
+      params.orderType,
+      params.deadline
     ]
-  },
-  {
-    name: "LiquidationSettled",
-    type: "event",
-    inputs: [
-      { name: "liquidationId", type: "uint256", indexed: true }
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+function preparePairClose(multiAccount, account, subAccount, longClose, shortClose) {
+  const longData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "requestToClosePosition",
+    args: [
+      longClose.quoteId,
+      longClose.closePrice,
+      longClose.quantityToClose,
+      longClose.orderType,
+      longClose.deadline
     ]
-  },
-  {
-    name: "SoftLiquidationPenalty",
-    type: "event",
-    inputs: [
-      { name: "partyB", type: "address", indexed: true },
-      { name: "level", type: "uint8", indexed: false },
-      { name: "penalty", type: "uint256", indexed: false }
+  });
+  const shortData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "requestToClosePosition",
+    args: [
+      shortClose.quoteId,
+      shortClose.closePrice,
+      shortClose.quantityToClose,
+      shortClose.orderType,
+      shortClose.deadline
     ]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [longData, shortData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: multiAccount, data: proxy.data, value: 0n }
+  };
+}
+async function closePosition(walletClient, publicClient, multiAccount, subAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareClosePosition(multiAccount, account, subAccount, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/actions/cancel.ts
+var cancel_exports = {};
+__export(cancel_exports, {
+  cancelCloseRequest: () => cancelCloseRequest,
+  cancelQuote: () => cancelQuote,
+  forceCancelCloseRequest: () => forceCancelCloseRequest,
+  forceCancelQuote: () => forceCancelQuote,
+  prepareCancelCloseRequest: () => prepareCancelCloseRequest,
+  prepareCancelQuote: () => prepareCancelQuote,
+  prepareForceCancelCloseRequest: () => prepareForceCancelCloseRequest,
+  prepareForceCancelQuote: () => prepareForceCancelQuote
+});
+function prepareCancelAction(accountDiamond, account, subAccount, functionName, quoteId) {
+  const innerData = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName,
+    args: [quoteId]
+  });
+  const proxy = wrapInProxyCall(
+    MultiAccountABI,
+    subAccount,
+    [innerData]
+  );
+  return {
+    functionName: "_call",
+    args: proxy.args,
+    config: { account, to: accountDiamond, data: proxy.data, value: 0n }
+  };
+}
+async function executeCancelAction(walletClient, publicClient, accountDiamond, subAccount, functionName, quoteId) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareCancelAction(
+    accountDiamond,
+    account,
+    subAccount,
+    functionName,
+    quoteId
+  );
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+function prepareCancelQuote(accountDiamond, account, subAccount, quoteId) {
+  return prepareCancelAction(
+    accountDiamond,
+    account,
+    subAccount,
+    "requestToCancelQuote",
+    quoteId
+  );
+}
+function prepareCancelCloseRequest(accountDiamond, account, subAccount, quoteId) {
+  return prepareCancelAction(
+    accountDiamond,
+    account,
+    subAccount,
+    "requestToCancelCloseRequest",
+    quoteId
+  );
+}
+function prepareForceCancelQuote(accountDiamond, account, subAccount, quoteId) {
+  return prepareCancelAction(
+    accountDiamond,
+    account,
+    subAccount,
+    "forceCancelQuote",
+    quoteId
+  );
+}
+function prepareForceCancelCloseRequest(accountDiamond, account, subAccount, quoteId) {
+  return prepareCancelAction(
+    accountDiamond,
+    account,
+    subAccount,
+    "forceCancelCloseRequest",
+    quoteId
+  );
+}
+async function cancelQuote(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
+  return executeCancelAction(
+    walletClient,
+    publicClient,
+    accountDiamond,
+    subAccount,
+    "requestToCancelQuote",
+    quoteId
+  );
+}
+async function cancelCloseRequest(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
+  return executeCancelAction(
+    walletClient,
+    publicClient,
+    accountDiamond,
+    subAccount,
+    "requestToCancelCloseRequest",
+    quoteId
+  );
+}
+async function forceCancelQuote(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
+  return executeCancelAction(
+    walletClient,
+    publicClient,
+    accountDiamond,
+    subAccount,
+    "forceCancelQuote",
+    quoteId
+  );
+}
+async function forceCancelCloseRequest(walletClient, publicClient, accountDiamond, subAccount, quoteId) {
+  return executeCancelAction(
+    walletClient,
+    publicClient,
+    accountDiamond,
+    subAccount,
+    "forceCancelCloseRequest",
+    quoteId
+  );
+}
+
+// src/actions/approval.ts
+var approval_exports = {};
+__export(approval_exports, {
+  ApprovalState: () => ApprovalState,
+  approve: () => approve,
+  getAllowance: () => getAllowance,
+  getApprovalState: () => getApprovalState,
+  getBalance: () => getBalance,
+  getDecimals: () => getDecimals,
+  prepareApprove: () => prepareApprove
+});
+var ApprovalState = /* @__PURE__ */ ((ApprovalState2) => {
+  ApprovalState2["UNKNOWN"] = "UNKNOWN";
+  ApprovalState2["NOT_APPROVED"] = "NOT_APPROVED";
+  ApprovalState2["PENDING"] = "PENDING";
+  ApprovalState2["APPROVED"] = "APPROVED";
+  return ApprovalState2;
+})(ApprovalState || {});
+function prepareApprove(tokenAddress, account, spender, amount) {
+  validateAddress(spender, "spender");
+  const data = viem.encodeFunctionData({
+    abi: ERC20ABI,
+    functionName: "approve",
+    args: [spender, amount]
+  });
+  return {
+    functionName: "approve",
+    args: [spender, amount],
+    config: { account, to: tokenAddress, data, value: 0n }
+  };
+}
+async function approve(walletClient, publicClient, tokenAddress, spender, amount) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareApprove(tokenAddress, account, spender, amount);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function getAllowance(publicClient, tokenAddress, owner, spender) {
+  return await publicClient.readContract({
+    address: tokenAddress,
+    abi: ERC20ABI,
+    functionName: "allowance",
+    args: [owner, spender]
+  });
+}
+async function getBalance(publicClient, tokenAddress, account) {
+  return await publicClient.readContract({
+    address: tokenAddress,
+    abi: ERC20ABI,
+    functionName: "balanceOf",
+    args: [account]
+  });
+}
+async function getDecimals(publicClient, tokenAddress) {
+  return await publicClient.readContract({
+    address: tokenAddress,
+    abi: ERC20ABI,
+    functionName: "decimals"
+  });
+}
+async function getApprovalState(publicClient, tokenAddress, owner, spender, requiredAmount) {
+  try {
+    const allowance = await getAllowance(publicClient, tokenAddress, owner, spender);
+    if (allowance >= requiredAmount) {
+      return "APPROVED" /* APPROVED */;
+    }
+    return "NOT_APPROVED" /* NOT_APPROVED */;
+  } catch {
+    return "UNKNOWN" /* UNKNOWN */;
+  }
+}
+
+// src/actions/delegation.ts
+var delegation_exports = {};
+__export(delegation_exports, {
+  delegateAccess: () => delegateAccess,
+  hasDelegatedAccess: () => hasDelegatedAccess,
+  prepareDelegateAccess: () => prepareDelegateAccess,
+  prepareProposeRevoke: () => prepareProposeRevoke,
+  prepareRevokeAccess: () => prepareRevokeAccess,
+  proposeRevoke: () => proposeRevoke,
+  revokeAccess: () => revokeAccess
+});
+function prepareDelegateAccess(multiAccount, account, params) {
+  validateAddress(params.account, "subAccount");
+  validateAddress(params.target, "target");
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "delegateAccesses",
+    args: [params.account, params.target, params.selectors, params.activate]
+  });
+  return {
+    functionName: "delegateAccesses",
+    args: [params.account, params.target, params.selectors, params.activate],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+function prepareProposeRevoke(multiAccount, account, params) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "proposeToRevokeAccesses",
+    args: [params.account, params.target, params.selectors]
+  });
+  return {
+    functionName: "proposeToRevokeAccesses",
+    args: [params.account, params.target, params.selectors],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+function prepareRevokeAccess(multiAccount, account, params) {
+  const data = viem.encodeFunctionData({
+    abi: MultiAccountABI,
+    functionName: "revokeAccesses",
+    args: [params.account, params.target, params.selectors]
+  });
+  return {
+    functionName: "revokeAccesses",
+    args: [params.account, params.target, params.selectors],
+    config: { account, to: multiAccount, data, value: 0n }
+  };
+}
+async function delegateAccess(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareDelegateAccess(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function proposeRevoke(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareProposeRevoke(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function revokeAccess(walletClient, publicClient, multiAccount, params) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareRevokeAccess(multiAccount, account, params);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function hasDelegatedAccess(publicClient, multiAccount, params) {
+  validateAddress(params.account, "subAccount");
+  validateAddress(params.target, "target");
+  const result = await publicClient.readContract({
+    address: multiAccount,
+    abi: MultiAccountABI,
+    functionName: "delegatedAccesses",
+    args: [params.account, params.target, params.selector]
+  });
+  return Boolean(result);
+}
+
+// src/actions/signature.ts
+var signature_exports = {};
+__export(signature_exports, {
+  getCurrentMessage: () => getCurrentMessage,
+  hasSignedCurrentVersion: () => hasSignedCurrentVersion,
+  prepareStoreSignature: () => prepareStoreSignature,
+  signTermsMessage: () => signTermsMessage,
+  storeSignature: () => storeSignature
+});
+function prepareStoreSignature(signatureStore, account, signature) {
+  const data = viem.encodeFunctionData({
+    abi: SignatureStoreABI,
+    functionName: "storeSignatureForCurrentVersion",
+    args: [signature]
+  });
+  return {
+    functionName: "storeSignatureForCurrentVersion",
+    args: [signature],
+    config: { account, to: signatureStore, data, value: 0n }
+  };
+}
+async function storeSignature(walletClient, publicClient, signatureStore, signature) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareStoreSignature(signatureStore, account, signature);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function signTermsMessage(walletClient, publicClient, signatureStore) {
+  const account = walletClient.account;
+  if (!account) throw new Error("Wallet client has no account");
+  const message = await publicClient.readContract({
+    address: signatureStore,
+    abi: SignatureStoreABI,
+    functionName: "getCurrentVersionMessage"
+  });
+  return walletClient.signMessage({
+    account,
+    message
+  });
+}
+async function hasSignedCurrentVersion(publicClient, signatureStore, user) {
+  return await publicClient.readContract({
+    address: signatureStore,
+    abi: SignatureStoreABI,
+    functionName: "hasCurrentVersionSignature",
+    args: [user]
+  });
+}
+async function getCurrentMessage(publicClient, signatureStore) {
+  return await publicClient.readContract({
+    address: signatureStore,
+    abi: SignatureStoreABI,
+    functionName: "getCurrentVersionMessage"
+  });
+}
+
+// src/actions/admin.ts
+var admin_exports = {};
+__export(admin_exports, {
+  grantRole: () => grantRole,
+  prepareGrantRole: () => prepareGrantRole,
+  prepareRevokeRole: () => prepareRevokeRole,
+  revokeRole: () => revokeRole
+});
+function prepareGrantRole(symmioDiamond, account, role, grantee) {
+  validateAddress(grantee, "grantee");
+  const data = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "grantRole",
+    args: [grantee, role]
+  });
+  return {
+    functionName: "grantRole",
+    args: [grantee, role],
+    config: { account, to: symmioDiamond, data, value: 0n }
+  };
+}
+function prepareRevokeRole(symmioDiamond, account, role, revokee) {
+  validateAddress(revokee, "revokee");
+  const data = viem.encodeFunctionData({
+    abi: SymmioDiamondABI,
+    functionName: "revokeRole",
+    args: [revokee, role]
+  });
+  return {
+    functionName: "revokeRole",
+    args: [revokee, role],
+    config: { account, to: symmioDiamond, data, value: 0n }
+  };
+}
+async function grantRole(walletClient, publicClient, symmioDiamond, role, grantee) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareGrantRole(symmioDiamond, account, role, grantee);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+async function revokeRole(walletClient, publicClient, symmioDiamond, role, revokee) {
+  const account = walletClient.account?.address;
+  if (!account) throw new Error("Wallet client has no account");
+  const prepared = prepareRevokeRole(symmioDiamond, account, role, revokee);
+  const gas = await publicClient.estimateGas(prepared.config);
+  return walletClient.sendTransaction({
+    ...prepared.config,
+    gas: calculateGasMargin(gas),
+    chain: walletClient.chain
+  });
+}
+
+// src/actions/instant.ts
+var instant_exports = {};
+__export(instant_exports, {
+  cancelInstantClose: () => cancelInstantClose,
+  createSiweMessage: () => createSiweMessage,
+  getNonce: () => getNonce,
+  getOpenInstantCloses: () => getOpenInstantCloses,
+  instantClose: () => instantClose,
+  instantOpen: () => instantOpen,
+  login: () => login
+});
+function getHedgerBaseUrl(chainId) {
+  const baseUrl = HEDGER_BASE_URLS[chainId];
+  if (!baseUrl) {
+    throw new Error(`No hedger base URL configured for chain ${chainId}.`);
   }
-];
-
-// src/abis/MuonVerifier.ts
-var MuonVerifierABI = [
-  {
-    name: "addSignatureKey",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "publicKey", type: "address" },
-      { name: "nodeId", type: "bytes32" }
-    ],
-    outputs: []
-  },
-  {
-    name: "removeSignatureKey",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [{ name: "publicKey", type: "address" }],
-    outputs: []
-  },
-  {
-    name: "rotateSignatureKey",
-    type: "function",
-    stateMutability: "nonpayable",
-    inputs: [
-      { name: "oldKey", type: "address" },
-      { name: "newKey", type: "address" }
-    ],
-    outputs: []
-  },
-  {
-    name: "isValidKey",
-    type: "function",
-    stateMutability: "view",
-    inputs: [{ name: "publicKey", type: "address" }],
-    outputs: [{ name: "valid", type: "bool" }]
-  },
-  {
-    name: "getActiveKeys",
-    type: "function",
-    stateMutability: "view",
-    inputs: [],
-    outputs: [{ name: "keys", type: "address[]" }]
+  return baseUrl;
+}
+function createSiweMessage(params) {
+  const version = params.version ?? "1";
+  const issuedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const expirationTime = new Date(
+    Date.now() + 30 * 24 * 60 * 60 * 1e3
+  ).toISOString();
+  const message = [
+    `${params.domain} wants you to sign in with your Ethereum account:`,
+    params.address,
+    "",
+    params.statement,
+    "",
+    `URI: ${params.uri}`,
+    `Version: ${version}`,
+    `Chain ID: ${params.chainId}`,
+    `Nonce: ${params.nonce}`,
+    `Issued At: ${issuedAt}`,
+    `Expiration Time: ${expirationTime}`
+  ].join("\n");
+  return { message, issuedAt, expirationTime };
+}
+async function getNonce(chainId, subAccount) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL(`nonce/${subAccount}`, hedgerBaseUrl).href;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch nonce: ${response.statusText}`);
   }
-];
+  const data = await response.json();
+  return data.nonce;
+}
+async function login(chainId, params) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL("login", hedgerBaseUrl).href;
+  const body = {
+    account_address: params.accountAddress,
+    expiration_time: params.expirationTime,
+    issued_at: params.issuedAt,
+    signature: params.signature,
+    nonce: params.nonce
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Login failed: ${response.statusText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.access_token) {
+    throw new Error("No access token received");
+  }
+  return {
+    accessToken: data.access_token,
+    expirationTime: params.expirationTime,
+    issuedAt: params.issuedAt
+  };
+}
+async function instantOpen(chainId, params, accessToken) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL("instant_open", hedgerBaseUrl).href;
+  const body = {
+    symbolId: params.symbolId,
+    positionType: params.positionType,
+    orderType: params.orderType,
+    price: params.price,
+    quantity: params.quantity,
+    cva: params.cva,
+    lf: params.lf,
+    partyAmm: params.partyAmm,
+    partyBmm: params.partyBmm,
+    maxFundingRate: params.maxFundingRate,
+    deadline: params.deadline
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Instant open failed: ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function instantClose(chainId, params, accessToken) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL("instant_close", hedgerBaseUrl).href;
+  const body = {
+    quote_id: params.quoteId,
+    quantity_to_close: params.quantityToClose,
+    close_price: params.closePrice
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Instant close failed: ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+async function cancelInstantClose(chainId, quoteId, accessToken) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL(`instant_close/${quoteId}`, hedgerBaseUrl).href;
+  const response = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Cancel instant close failed: ${response.statusText}`
+    );
+  }
+}
+async function getOpenInstantCloses(chainId, account, accessToken) {
+  const hedgerBaseUrl = getHedgerBaseUrl(chainId);
+  const url = new URL(`instant_close/${account}`, hedgerBaseUrl).href;
+  const response = await fetch(url, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    const errorData = await response.json().catch(() => null);
+    throw new Error(
+      errorData?.error_message ?? `Failed to fetch instant closes: ${response.statusText}`
+    );
+  }
+  return response.json();
+}
 
-// src/constants/selectors.ts
-var SEND_QUOTE_WITH_AFFILIATE_SELECTOR = "0x40f1310c";
-var CLOSE_QUOTE_SELECTOR = "0x501e891f";
-var ALL_TRADING_SELECTORS = [
-  SEND_QUOTE_WITH_AFFILIATE_SELECTOR,
-  CLOSE_QUOTE_SELECTOR
-];
+// src/actions/stats.ts
+var stats_exports = {};
+__export(stats_exports, {
+  calculateAvailableForOrder: () => calculateAvailableForOrder,
+  getPartyAStats: () => getPartyAStats
+});
+async function getPartyAStats(publicClient, symmioDiamond, partyA) {
+  const result = await publicClient.readContract({
+    address: symmioDiamond,
+    abi: SymmioDiamondABI,
+    functionName: "partyAStats",
+    args: [partyA]
+  });
+  return {
+    collateralBalance: result[1],
+    allocatedBalance: result[2],
+    availableBalance: result[3],
+    lockedCVA: result[4],
+    lockedLF: result[5],
+    lockedPartyAMM: result[6],
+    lockedPartyBMM: result[7],
+    pendingLockedCVA: result[8],
+    pendingLockedLF: result[9],
+    pendingLockedPartyAMM: result[10],
+    pendingLockedPartyBMM: result[11],
+    positionsCount: Number(result[12]),
+    pendingCount: Number(result[13]),
+    nonces: 0
+  };
+}
+function calculateAvailableForOrder(stats, upnl) {
+  const {
+    allocatedBalance,
+    lockedCVA,
+    lockedLF,
+    lockedPartyAMM,
+    pendingLockedCVA,
+    pendingLockedLF,
+    pendingLockedPartyAMM
+  } = stats;
+  const totalPendingLocked = pendingLockedCVA + pendingLockedLF + pendingLockedPartyAMM;
+  if (upnl >= 0n) {
+    const totalLocked = lockedCVA + lockedLF + lockedPartyAMM;
+    return allocatedBalance + upnl - totalLocked - totalPendingLocked;
+  }
+  const absUpnl = -upnl;
+  const consideringMm = absUpnl > lockedPartyAMM ? absUpnl : lockedPartyAMM;
+  return allocatedBalance - lockedCVA - lockedLF - totalPendingLocked - consideringMm;
+}
 
 // src/utils/formatting.ts
 function toWei(amount, decimals) {
@@ -25018,7 +24681,6 @@ exports.SignatureStoreABI = SignatureStoreABI;
 exports.SoftLiquidationLevel = SoftLiquidationLevel;
 exports.SupportedChainId = SupportedChainId;
 exports.SymmioDiamondABI = SymmioDiamondABI;
-exports.SymmioSDK = SymmioSDK;
 exports.SymmioSDKError = SymmioSDKError;
 exports.V3_CHAIN_IDS = V3_CHAIN_IDS;
 exports.accountActions = account_exports;