opentool 0.7.13 → 0.8.0

package/dist/index.js

@@ -6,11 +6,14 @@ import * as path5 from 'path';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { zodToJsonSchema } from '@alcyone-labs/zod-to-json-schema';
 import { z } from 'zod';
-import { zeroAddress, createWalletClient, http, createPublicClient } from 'viem';
+import { zeroAddress, createWalletClient, http, createPublicClient, parseUnits, encodeFunctionData, erc20Abi } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia, arbitrum, baseSepolia, mainnet, base } from 'viem/chains';
 import { Turnkey } from '@turnkey/sdk-server';
 import { createAccount } from '@turnkey/viem';
+import { encode } from '@msgpack/msgpack';
+import { keccak_256 } from '@noble/hashes/sha3';
+import { hexToBytes, concatBytes, bytesToHex } from '@noble/hashes/utils';
 import { tmpdir } from 'os';
 import { build } from 'esbuild';
 import { createRequire } from 'module';
@@ -1343,6 +1346,18 @@ function normalizePrivateKey(raw) {
   }
   return withPrefix;
 }
+function createNonceSource(start = Date.now()) {
+  let last = start;
+  return () => {
+    const now = Date.now();
+    if (now > last) {
+      last = now;
+    } else {
+      last += 1;
+    }
+    return last;
+  };
+}
 function createPrivateKeyProvider(config) {
   const privateKey = normalizePrivateKey(config.privateKey);
   const account = privateKeyToAccount(privateKey);
@@ -1388,7 +1403,20 @@ function createPrivateKeyProvider(config) {
     publicClient,
     sendTransaction,
     getNativeBalance,
-    transfer
+    transfer,
+    nonceSource: createNonceSource()
+  };
+}
+function createNonceSource2(start = Date.now()) {
+  let last = start;
+  return () => {
+    const now = Date.now();
+    if (now > last) {
+      last = now;
+    } else {
+      last += 1;
+    }
+    return last;
   };
 }
 async function createTurnkeyProvider(config) {
@@ -1446,11 +1474,12 @@ async function createTurnkeyProvider(config) {
     publicClient,
     sendTransaction,
     getNativeBalance,
-    transfer
+    transfer,
+    nonceSource: createNonceSource2()
   };
 }
 
-// src/wallets/index.ts
+// src/wallet/index.ts
 function resolveChainSlug(reference) {
   if (reference === void 0) {
     return Object.entries(chains).find(([, meta]) => meta.id === DEFAULT_CHAIN.id)?.[0] || DEFAULT_CHAIN.slug;
@@ -1492,40 +1521,59 @@ function getRpcUrl(chain, options) {
   return entry.rpcUrl(options);
 }
 async function wallet(options = {}) {
-  if (options.privateKey && options.turnkey) {
+  const envPrivateKey = process.env.PRIVATE_KEY?.trim();
+  const envTurnkey = {
+    organizationId: process.env.TURNKEY_SUBORG_ID?.trim(),
+    apiPublicKey: process.env.TURNKEY_API_PUBLIC_KEY?.trim(),
+    apiPrivateKey: process.env.TURNKEY_API_PRIVATE_KEY?.trim(),
+    signWith: process.env.TURNKEY_WALLET_ADDRESS?.trim(),
+    apiBaseUrl: process.env.TURNKEY_API_BASE_URL?.trim()
+  };
+  const effectivePrivateKey = options.privateKey ?? envPrivateKey;
+  const hasTurnkeyEnv = envTurnkey.organizationId && envTurnkey.apiPublicKey && envTurnkey.apiPrivateKey && envTurnkey.signWith;
+  const effectiveTurnkey = options.turnkey ?? (hasTurnkeyEnv ? {
+    organizationId: envTurnkey.organizationId,
+    apiPublicKey: envTurnkey.apiPublicKey,
+    apiPrivateKey: envTurnkey.apiPrivateKey,
+    signWith: envTurnkey.signWith,
+    ...envTurnkey.apiBaseUrl ? { apiBaseUrl: envTurnkey.apiBaseUrl } : {}
+  } : void 0);
+  if (effectivePrivateKey && effectiveTurnkey) {
     throw new Error("wallet() cannot be initialized with both privateKey and turnkey credentials");
   }
   const slug = resolveChainSlug(options.chain);
   const chain = chains[slug];
   const tokens2 = tokens[slug] ?? {};
   const overrides = {};
-  if (options.rpcUrl) {
-    overrides.url = options.rpcUrl;
+  const envRpcUrl = process.env.RPC_URL?.trim();
+  const envApiKey = process.env.ALCHEMY_API_KEY?.trim();
+  if (options.rpcUrl ?? envRpcUrl) {
+    overrides.url = options.rpcUrl ?? envRpcUrl;
   }
-  if (options.apiKey) {
-    overrides.apiKey = options.apiKey;
+  if (options.apiKey ?? envApiKey) {
+    overrides.apiKey = options.apiKey ?? envApiKey;
   }
   const rpcUrl = getRpcUrl(slug, overrides);
   let providerType = "readonly";
   let signerProvider;
-  if (options.privateKey) {
+  if (effectivePrivateKey) {
     signerProvider = createPrivateKeyProvider({
       chain,
       rpcUrl,
-      privateKey: options.privateKey
+      privateKey: effectivePrivateKey
     });
     providerType = "privateKey";
-  } else if (options.turnkey) {
+  } else if (effectiveTurnkey) {
     const turnkeyConfig = {
       chain,
       rpcUrl,
-      organizationId: options.turnkey.organizationId,
-      apiPublicKey: options.turnkey.apiPublicKey,
-      apiPrivateKey: options.turnkey.apiPrivateKey,
-      signWith: options.turnkey.signWith
+      organizationId: effectiveTurnkey.organizationId,
+      apiPublicKey: effectiveTurnkey.apiPublicKey,
+      apiPrivateKey: effectiveTurnkey.apiPrivateKey,
+      signWith: effectiveTurnkey.signWith
     };
-    if (options.turnkey.apiBaseUrl) {
-      turnkeyConfig.apiBaseUrl = options.turnkey.apiBaseUrl;
+    if (effectiveTurnkey.apiBaseUrl) {
+      turnkeyConfig.apiBaseUrl = effectiveTurnkey.apiBaseUrl;
     }
     signerProvider = await createTurnkeyProvider(turnkeyConfig);
     providerType = "turnkey";
@@ -1540,7 +1588,8 @@ async function wallet(options = {}) {
     rpcUrl,
     providerType,
     publicClient,
-    getRpcUrl: (override) => getRpcUrl(slug, override)
+    getRpcUrl: (override) => getRpcUrl(slug, override),
+    ...signerProvider ? { address: signerProvider.address } : {}
   };
   if (signerProvider) {
     const { publicClient: _ignored, ...rest } = signerProvider;
@@ -1563,6 +1612,1450 @@ var walletToolkit = {
   wallet
 };
 
+// src/store/index.ts
+var StoreError = class extends Error {
+  constructor(message, status, causeData) {
+    super(message);
+    this.status = status;
+    this.causeData = causeData;
+    this.name = "StoreError";
+  }
+};
+function resolveConfig(options) {
+  const baseUrl = options?.baseUrl ?? process.env.BASE_URL ?? "https://api.openpond.ai";
+  const apiKey = options?.apiKey ?? process.env.OPENPOND_API_KEY;
+  if (!baseUrl) {
+    throw new StoreError("BASE_URL is required to store activity events");
+  }
+  if (!apiKey) {
+    throw new StoreError(
+      "OPENPOND_API_KEY is required to store activity events"
+    );
+  }
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const fetchFn = options?.fetchFn ?? globalThis.fetch;
+  if (!fetchFn) {
+    throw new StoreError("Fetch is not available in this environment");
+  }
+  return { baseUrl: normalizedBaseUrl, apiKey, fetchFn };
+}
+async function store(input, options) {
+  const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
+  const url = `${baseUrl}/apps/positions/tx`;
+  let response;
+  try {
+    response = await fetchFn(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "openpond-api-key": apiKey
+      },
+      body: JSON.stringify(input)
+    });
+  } catch (error) {
+    throw new StoreError("Failed to reach store endpoint", void 0, error);
+  }
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = await response.text().catch(() => void 0);
+    }
+    throw new StoreError(
+      `Store request failed with status ${response.status}`,
+      response.status,
+      body
+    );
+  }
+  try {
+    const data = await response.json();
+    return {
+      id: data.id ?? "",
+      status: data.status ?? null
+    };
+  } catch {
+    return { id: "", status: null };
+  }
+}
+async function retrieve(params, options) {
+  const { baseUrl, apiKey, fetchFn } = resolveConfig(options);
+  const url = new URL(`${baseUrl}/apps/positions/tx`);
+  if (params?.source) url.searchParams.set("source", params.source);
+  if (params?.walletAddress) url.searchParams.set("walletAddress", params.walletAddress);
+  if (params?.symbol) url.searchParams.set("symbol", params.symbol);
+  if (params?.status?.length) url.searchParams.set("status", params.status.join(","));
+  if (typeof params?.since === "number") url.searchParams.set("since", params.since.toString());
+  if (typeof params?.until === "number") url.searchParams.set("until", params.until.toString());
+  if (typeof params?.limit === "number") url.searchParams.set("limit", params.limit.toString());
+  if (params?.cursor) url.searchParams.set("cursor", params.cursor);
+  if (params?.history) url.searchParams.set("history", "true");
+  let response;
+  try {
+    response = await fetchFn(url.toString(), {
+      method: "GET",
+      headers: {
+        "content-type": "application/json",
+        "openpond-api-key": apiKey
+      }
+    });
+  } catch (error) {
+    throw new StoreError("Failed to reach store endpoint", void 0, error);
+  }
+  if (!response.ok) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = await response.text().catch(() => void 0);
+    }
+    throw new StoreError(
+      `Store retrieve failed with status ${response.status}`,
+      response.status,
+      body
+    );
+  }
+  const data = await response.json().catch(() => null);
+  if (!data) {
+    return { items: [], cursor: null };
+  }
+  return data;
+}
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var API_BASES = {
+  mainnet: "https://api.hyperliquid.xyz",
+  testnet: "https://api.hyperliquid-testnet.xyz"
+};
+var HL_ENDPOINT = {
+  mainnet: "https://api.hyperliquid.xyz",
+  testnet: "https://api.hyperliquid-testnet.xyz"
+};
+var HL_CHAIN_LABEL = {
+  mainnet: "Mainnet",
+  testnet: "Testnet"
+};
+var HL_BRIDGE_ADDRESSES = {
+  mainnet: "0x2df1c51e09aecf9cacb7bc98cb1742757f163df7",
+  testnet: "0x08cfc1b6b2dcf36a1480b99353a354aa8ac56f89"
+};
+var HL_USDC_ADDRESSES = {
+  mainnet: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+  testnet: "0x1baAbB04529D43a73232B713C0FE471f7c7334d5"
+};
+var HL_SIGNATURE_CHAIN_ID = {
+  mainnet: "0xa4b1",
+  testnet: "0x66eee"
+};
+var EXCHANGE_TYPED_DATA_DOMAIN = {
+  name: "Exchange",
+  version: "1",
+  chainId: 1337,
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var MIN_DEPOSIT_USDC = 5;
+var BUILDER_CODE = {
+  address: "0x4b2aec4F91612849d6e20C9c1881FabB1A48cd12",
+  fee: 100
+};
+var metaCache = /* @__PURE__ */ new Map();
+var HyperliquidApiError = class extends Error {
+  constructor(message, response) {
+    super(message);
+    this.response = response;
+    this.name = "HyperliquidApiError";
+  }
+};
+var HyperliquidGuardError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HyperliquidGuardError";
+  }
+};
+var HyperliquidTermsError = class extends HyperliquidGuardError {
+  constructor(message = "Hyperliquid terms must be accepted before proceeding.") {
+    super(message);
+    this.name = "HyperliquidTermsError";
+  }
+};
+var HyperliquidBuilderApprovalError = class extends HyperliquidGuardError {
+  constructor(message = "Hyperliquid builder approval is required before using builder codes.") {
+    super(message);
+    this.name = "HyperliquidBuilderApprovalError";
+  }
+};
+function createMonotonicNonceFactory(start = Date.now()) {
+  let last = start;
+  return () => {
+    const now = Date.now();
+    if (now > last) {
+      last = now;
+    } else {
+      last += 1;
+    }
+    return last;
+  };
+}
+async function getUniverse(args) {
+  const cacheKey = `${args.environment}:${args.baseUrl}`;
+  const cached = metaCache.get(cacheKey);
+  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
+    return cached.universe;
+  }
+  const response = await args.fetcher(`${args.baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "meta" })
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok || !json?.universe) {
+    throw new HyperliquidApiError(
+      "Unable to load Hyperliquid metadata.",
+      json ?? { status: response.status }
+    );
+  }
+  metaCache.set(cacheKey, { fetchedAt: Date.now(), universe: json.universe });
+  return json.universe;
+}
+function resolveAssetIndex(symbol, universe) {
+  const [raw] = symbol.split("-");
+  const target = raw.trim();
+  const index = universe.findIndex(
+    (entry) => entry.name.toUpperCase() === target.toUpperCase()
+  );
+  if (index === -1) {
+    throw new Error(`Unknown Hyperliquid asset symbol: ${symbol}`);
+  }
+  return index;
+}
+function toApiDecimal(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (!Number.isFinite(value)) {
+    throw new Error("Numeric values must be finite.");
+  }
+  const asString = value.toString();
+  if (/e/i.test(asString)) {
+    const [mantissa, exponentPart] = asString.split(/e/i);
+    const exponent = Number(exponentPart);
+    const [integerPart, fractionalPart = ""] = mantissa.split(".");
+    if (exponent >= 0) {
+      return integerPart + fractionalPart.padEnd(exponent + fractionalPart.length, "0");
+    }
+    const zeros = "0".repeat(Math.abs(exponent) - 1);
+    return `0.${zeros}${integerPart}${fractionalPart}`.replace(/\.0+$/, "");
+  }
+  return asString;
+}
+function normalizeHex(value) {
+  const lower = value.toLowerCase();
+  return lower.replace(/^0x0+/, "0x") || "0x0";
+}
+function normalizeAddress(value) {
+  return normalizeHex(value);
+}
+async function signL1Action(args) {
+  const { wallet: wallet2, action, nonce, vaultAddress, expiresAfter, isTestnet } = args;
+  const actionHash = createL1ActionHash({
+    action,
+    nonce,
+    vaultAddress,
+    expiresAfter
+  });
+  const message = {
+    source: isTestnet ? "b" : "a",
+    connectionId: actionHash
+  };
+  const signatureHex = await wallet2.walletClient.signTypedData({
+    account: wallet2.account,
+    domain: EXCHANGE_TYPED_DATA_DOMAIN,
+    types: {
+      Agent: [
+        { name: "source", type: "string" },
+        { name: "connectionId", type: "bytes32" }
+      ]
+    },
+    primaryType: "Agent",
+    message
+  });
+  return splitSignature(signatureHex);
+}
+async function signSpotSend(args) {
+  const {
+    wallet: wallet2,
+    hyperliquidChain,
+    signatureChainId,
+    destination,
+    token: token2,
+    amount,
+    time
+  } = args;
+  const domain = {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId: Number.parseInt(signatureChainId, 16),
+    verifyingContract: ZERO_ADDRESS
+  };
+  const message = {
+    hyperliquidChain,
+    destination,
+    token: token2,
+    amount,
+    time
+  };
+  const types = {
+    "HyperliquidTransaction:SpotSend": [
+      { name: "hyperliquidChain", type: "string" },
+      { name: "destination", type: "string" },
+      { name: "token", type: "string" },
+      { name: "amount", type: "string" },
+      { name: "time", type: "uint64" }
+    ]
+  };
+  const signatureHex = await wallet2.walletClient.signTypedData({
+    account: wallet2.account,
+    domain,
+    types,
+    primaryType: "HyperliquidTransaction:SpotSend",
+    message
+  });
+  return splitSignature(signatureHex);
+}
+async function signApproveBuilderFee(args) {
+  const { wallet: wallet2, maxFeeRate, nonce, signatureChainId, isTestnet } = args;
+  const hyperliquidChain = isTestnet ? "Testnet" : "Mainnet";
+  const domain = {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId: Number.parseInt(signatureChainId, 16),
+    verifyingContract: ZERO_ADDRESS
+  };
+  const message = {
+    hyperliquidChain,
+    maxFeeRate,
+    builder: BUILDER_CODE.address,
+    nonce
+  };
+  const types = {
+    "HyperliquidTransaction:ApproveBuilderFee": [
+      { name: "hyperliquidChain", type: "string" },
+      { name: "maxFeeRate", type: "string" },
+      { name: "builder", type: "address" },
+      { name: "nonce", type: "uint64" }
+    ]
+  };
+  const signatureHex = await wallet2.walletClient.signTypedData({
+    account: wallet2.account,
+    domain,
+    types,
+    primaryType: "HyperliquidTransaction:ApproveBuilderFee",
+    message
+  });
+  return splitSignature(signatureHex);
+}
+function splitSignature(signature) {
+  const cleaned = signature.slice(2);
+  const rHex = `0x${cleaned.slice(0, 64)}`;
+  const sHex = `0x${cleaned.slice(64, 128)}`;
+  let v = parseInt(cleaned.slice(128, 130), 16);
+  if (Number.isNaN(v)) {
+    throw new Error("Invalid signature returned by wallet client.");
+  }
+  if (v < 27) {
+    v += 27;
+  }
+  const normalizedV = v === 27 || v === 28 ? v : v % 2 ? 27 : 28;
+  return {
+    r: normalizeHex(rHex),
+    s: normalizeHex(sHex),
+    v: normalizedV
+  };
+}
+function createL1ActionHash(args) {
+  const { action, nonce, vaultAddress, expiresAfter } = args;
+  const actionBytes = encode(action, { ignoreUndefined: true });
+  const nonceBytes = toUint64Bytes(nonce);
+  const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
+  const vaultBytes = vaultAddress ? hexToBytes(vaultAddress.slice(2)) : new Uint8Array();
+  const hasExpiresAfter = typeof expiresAfter === "number";
+  const expiresMarker = hasExpiresAfter ? new Uint8Array([0]) : new Uint8Array();
+  const expiresBytes = hasExpiresAfter && expiresAfter !== void 0 ? toUint64Bytes(expiresAfter) : new Uint8Array();
+  const bytes = concatBytes(
+    actionBytes,
+    nonceBytes,
+    vaultMarker,
+    vaultBytes,
+    expiresMarker,
+    expiresBytes
+  );
+  const hash = keccak_256(bytes);
+  return `0x${bytesToHex(hash)}`;
+}
+function toUint64Bytes(value) {
+  const bytes = new Uint8Array(8);
+  new DataView(bytes.buffer).setBigUint64(0, BigInt(value));
+  return bytes;
+}
+function getBridgeAddress(env) {
+  const override = process.env.HYPERLIQUID_BRIDGE_ADDRESS;
+  if (override?.trim()) {
+    return normalizeAddress(override);
+  }
+  return HL_BRIDGE_ADDRESSES[env];
+}
+function getUsdcAddress(env) {
+  const override = process.env.HYPERLIQUID_USDC_ADDRESS;
+  if (override?.trim()) {
+    return normalizeAddress(override);
+  }
+  return HL_USDC_ADDRESSES[env];
+}
+function getSignatureChainId(env) {
+  const override = process.env.HYPERLIQUID_SIGNATURE_CHAIN_ID;
+  const selected = override?.trim() || HL_SIGNATURE_CHAIN_ID[env];
+  return normalizeHex(selected);
+}
+function assertPositiveNumber(value, label) {
+  if (!Number.isFinite(value) || value <= 0) {
+    throw new Error(`${label} must be a positive number.`);
+  }
+}
+
+// src/adapters/hyperliquid/exchange.ts
+var HyperliquidExchangeClient = class {
+  constructor(args) {
+    this.wallet = args.wallet;
+    this.environment = args.environment ?? "mainnet";
+    this.vaultAddress = args.vaultAddress;
+    this.expiresAfter = args.expiresAfter;
+    const resolvedNonceSource = args.walletNonceProvider ?? args.wallet.nonceSource ?? args.nonceSource;
+    if (!resolvedNonceSource) {
+      throw new Error(
+        "Wallet nonce source is required for Hyperliquid exchange actions."
+      );
+    }
+    this.nonceSource = resolvedNonceSource;
+  }
+  cancel(cancels) {
+    return cancelHyperliquidOrders({
+      wallet: this.wallet,
+      cancels,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  cancelByCloid(cancels) {
+    return cancelHyperliquidOrdersByCloid({
+      wallet: this.wallet,
+      cancels,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  cancelAll() {
+    return cancelAllHyperliquidOrders({
+      wallet: this.wallet,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  scheduleCancel(time) {
+    return scheduleHyperliquidCancel({
+      wallet: this.wallet,
+      time,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  modify(modification) {
+    return modifyHyperliquidOrder({
+      wallet: this.wallet,
+      modification,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  batchModify(modifications) {
+    return batchModifyHyperliquidOrders({
+      wallet: this.wallet,
+      modifications,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  twapOrder(twap) {
+    return placeHyperliquidTwapOrder({
+      wallet: this.wallet,
+      twap,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  twapCancel(cancel) {
+    return cancelHyperliquidTwapOrder({
+      wallet: this.wallet,
+      cancel,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  updateLeverage(input) {
+    return updateHyperliquidLeverage({
+      wallet: this.wallet,
+      input,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  updateIsolatedMargin(input) {
+    return updateHyperliquidIsolatedMargin({
+      wallet: this.wallet,
+      input,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  reserveRequestWeight(weight) {
+    return reserveHyperliquidRequestWeight({
+      wallet: this.wallet,
+      weight,
+      environment: this.environment,
+      vaultAddress: this.vaultAddress,
+      expiresAfter: this.expiresAfter,
+      nonceSource: this.nonceSource
+    });
+  }
+  spotSend(params) {
+    return sendHyperliquidSpot({
+      wallet: this.wallet,
+      environment: this.environment,
+      nonceSource: this.nonceSource,
+      ...params
+    });
+  }
+};
+async function cancelHyperliquidOrders(options) {
+  options.cancels.forEach((c) => assertSymbol(c.symbol));
+  const action = {
+    type: "cancel",
+    cancels: await withAssetIndexes(options, options.cancels, (idx, entry) => ({
+      a: idx,
+      o: entry.oid
+    }))
+  };
+  return submitExchangeAction(options, action);
+}
+async function cancelHyperliquidOrdersByCloid(options) {
+  options.cancels.forEach((c) => assertSymbol(c.symbol));
+  const action = {
+    type: "cancelByCloid",
+    cancels: await withAssetIndexes(
+      options,
+      options.cancels,
+      (idx, entry) => ({
+        a: idx,
+        c: normalizeAddress(entry.cloid)
+      })
+    )
+  };
+  return submitExchangeAction(options, action);
+}
+async function cancelAllHyperliquidOrders(options) {
+  const action = { type: "cancelAll" };
+  return submitExchangeAction(options, action);
+}
+async function scheduleHyperliquidCancel(options) {
+  if (options.time !== null) {
+    assertPositiveNumber(options.time, "time");
+  }
+  const action = { type: "scheduleCancel", time: options.time };
+  return submitExchangeAction(options, action);
+}
+async function modifyHyperliquidOrder(options) {
+  const { modification } = options;
+  const order = await buildOrder(modification.order, options);
+  const action = {
+    type: "modify",
+    oid: modification.oid,
+    order
+  };
+  return submitExchangeAction(options, action);
+}
+async function batchModifyHyperliquidOrders(options) {
+  options.modifications.forEach((m) => assertSymbol(m.order.symbol));
+  const modifies = await Promise.all(
+    options.modifications.map(async (mod) => ({
+      oid: mod.oid,
+      order: await buildOrder(mod.order, options)
+    }))
+  );
+  const action = {
+    type: "batchModify",
+    modifies
+  };
+  return submitExchangeAction(options, action);
+}
+async function placeHyperliquidTwapOrder(options) {
+  const { twap } = options;
+  assertSymbol(twap.symbol);
+  assertPositiveDecimal(twap.size, "size");
+  assertPositiveNumber(twap.minutes, "minutes");
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  const asset = resolveAssetIndex(twap.symbol, universe);
+  const action = {
+    type: "twapOrder",
+    twap: {
+      a: asset,
+      b: twap.side === "buy",
+      s: toApiDecimal(twap.size),
+      r: Boolean(twap.reduceOnly),
+      m: twap.minutes,
+      t: Boolean(twap.randomize)
+    }
+  };
+  return submitExchangeAction(options, action);
+}
+async function cancelHyperliquidTwapOrder(options) {
+  assertSymbol(options.cancel.symbol);
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  const asset = resolveAssetIndex(options.cancel.symbol, universe);
+  const action = {
+    type: "twapCancel",
+    a: asset,
+    t: options.cancel.twapId
+  };
+  return submitExchangeAction(options, action);
+}
+async function updateHyperliquidLeverage(options) {
+  assertSymbol(options.input.symbol);
+  assertPositiveNumber(options.input.leverage, "leverage");
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  const asset = resolveAssetIndex(options.input.symbol, universe);
+  const action = {
+    type: "updateLeverage",
+    asset,
+    isCross: options.input.leverageMode === "cross",
+    leverage: options.input.leverage
+  };
+  return submitExchangeAction(options, action);
+}
+async function updateHyperliquidIsolatedMargin(options) {
+  assertSymbol(options.input.symbol);
+  assertPositiveNumber(options.input.ntli, "ntli");
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  const asset = resolveAssetIndex(options.input.symbol, universe);
+  const action = {
+    type: "updateIsolatedMargin",
+    asset,
+    isBuy: options.input.isBuy,
+    ntli: options.input.ntli
+  };
+  return submitExchangeAction(options, action);
+}
+async function reserveHyperliquidRequestWeight(options) {
+  assertPositiveNumber(options.weight, "weight");
+  const action = {
+    type: "reserveRequestWeight",
+    weight: options.weight
+  };
+  return submitExchangeAction(options, action);
+}
+async function createHyperliquidSubAccount(options) {
+  assertString(options.name, "name");
+  const action = {
+    type: "createSubAccount",
+    name: options.name
+  };
+  return submitExchangeAction(options, action);
+}
+async function transferHyperliquidSubAccount(options) {
+  assertString(options.subAccountUser, "subAccountUser");
+  const usdScaled = normalizeUsdToInt(options.usd);
+  const action = {
+    type: "subAccountTransfer",
+    subAccountUser: normalizeAddress(options.subAccountUser),
+    isDeposit: Boolean(options.isDeposit),
+    usd: usdScaled
+  };
+  return submitExchangeAction(options, action);
+}
+async function sendHyperliquidSpot(options) {
+  const env = options.environment ?? "mainnet";
+  if (!options.wallet.account || !options.wallet.walletClient) {
+    throw new Error("Wallet with signing capability is required for spotSend.");
+  }
+  assertString(options.token, "token");
+  assertPositiveDecimal(options.amount, "amount");
+  const signatureChainId = getSignatureChainId(env);
+  const hyperliquidChain = HL_CHAIN_LABEL[env];
+  const nonce = options.nonce ?? options.nonceSource?.() ?? Date.now();
+  const time = BigInt(nonce);
+  const signature = await signSpotSend({
+    wallet: options.wallet,
+    hyperliquidChain,
+    signatureChainId,
+    destination: normalizeAddress(options.destination),
+    token: options.token,
+    amount: toApiDecimal(options.amount),
+    time
+  });
+  const action = {
+    type: "spotSend",
+    hyperliquidChain,
+    signatureChainId,
+    destination: normalizeAddress(options.destination),
+    token: options.token,
+    amount: toApiDecimal(options.amount),
+    time: nonce
+  };
+  return postExchange(env, { action, nonce, signature });
+}
+async function submitExchangeAction(options, action) {
+  if (!options.wallet?.account || !options.wallet.walletClient) {
+    throw new Error("Hyperliquid exchange actions require a signing wallet.");
+  }
+  const env = options.environment ?? "mainnet";
+  const nonceSource = options.walletNonceProvider ?? options.wallet.nonceSource ?? options.nonceSource;
+  if (!nonceSource && options.nonce === void 0) {
+    throw new Error("Wallet nonce source is required for Hyperliquid exchange actions.");
+  }
+  const effectiveNonce = options.nonce ?? nonceSource?.();
+  if (effectiveNonce === void 0) {
+    throw new Error("Hyperliquid exchange actions require a nonce.");
+  }
+  const signature = await signL1Action({
+    wallet: options.wallet,
+    action,
+    nonce: effectiveNonce,
+    vaultAddress: options.vaultAddress ? normalizeAddress(options.vaultAddress) : void 0,
+    expiresAfter: options.expiresAfter,
+    isTestnet: env === "testnet"
+  });
+  const body = {
+    action,
+    nonce: effectiveNonce,
+    signature
+  };
+  if (options.vaultAddress) {
+    body.vaultAddress = normalizeAddress(options.vaultAddress);
+  }
+  if (typeof options.expiresAfter === "number") {
+    body.expiresAfter = options.expiresAfter;
+  }
+  return postExchange(env, body);
+}
+async function withAssetIndexes(options, entries, mapper) {
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  return Promise.all(
+    entries.map(async (entry) => {
+      const assetIndex = resolveAssetIndex(entry.symbol, universe);
+      return mapper(assetIndex, entry);
+    })
+  );
+}
+async function buildOrder(intent, options) {
+  assertSymbol(intent.symbol);
+  assertPositiveDecimal(intent.price, "price");
+  assertPositiveDecimal(intent.size, "size");
+  const env = options.environment ?? "mainnet";
+  const universe = await getUniverse({
+    baseUrl: API_BASES[env],
+    environment: env,
+    fetcher: fetch
+  });
+  const assetIndex = resolveAssetIndex(intent.symbol, universe);
+  const limitOrTrigger = intent.trigger ? mapTrigger(intent.trigger) : {
+    limit: {
+      tif: intent.tif ?? "Ioc"
+    }
+  };
+  return {
+    a: assetIndex,
+    b: intent.side === "buy",
+    p: toApiDecimal(intent.price),
+    s: toApiDecimal(intent.size),
+    r: intent.reduceOnly ?? false,
+    t: limitOrTrigger,
+    ...intent.clientId ? {
+      c: normalizeAddress(intent.clientId)
+    } : {}
+  };
+}
+function mapTrigger(trigger) {
+  assertPositiveDecimal(trigger.triggerPx, "triggerPx");
+  return {
+    trigger: {
+      isMarket: Boolean(trigger.isMarket),
+      triggerPx: toApiDecimal(trigger.triggerPx),
+      tpsl: trigger.tpsl
+    }
+  };
+}
+function assertSymbol(value) {
+  assertString(value, "symbol");
+}
+function normalizeUsdToInt(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw new Error("usd must be non-negative.");
+    }
+    return Number(value);
+  }
+  const parsed = typeof value === "string" ? Number.parseFloat(value) : Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error("usd must be a non-negative number.");
+  }
+  return Math.round(parsed * 1e6);
+}
+function assertString(value, label) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${label} must be a non-empty string.`);
+  }
+}
+function assertPositiveDecimal(value, label) {
+  if (typeof value === "number") {
+    assertPositiveNumber(value, label);
+    return;
+  }
+  if (typeof value === "bigint") {
+    if (value <= 0n) {
+      throw new Error(`${label} must be positive.`);
+    }
+    return;
+  }
+  assertString(value, label);
+}
+async function postExchange(env, body) {
+  const response = await fetch(`${API_BASES[env]}/exchange`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok || !json) {
+    throw new HyperliquidApiError(
+      "Hyperliquid exchange action failed.",
+      json ?? { status: response.status }
+    );
+  }
+  if (json.status !== "ok") {
+    throw new HyperliquidApiError("Hyperliquid exchange returned error.", json);
+  }
+  return json;
+}
+
+// src/adapters/hyperliquid/info.ts
+async function postInfo(environment, payload) {
+  const baseUrl = API_BASES[environment];
+  const response = await fetch(`${baseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const data = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new HyperliquidApiError(
+      "Hyperliquid info request failed.",
+      data ?? { status: response.status }
+    );
+  }
+  return data;
+}
+var HyperliquidInfoClient = class {
+  constructor(environment = "mainnet") {
+    this.environment = environment;
+  }
+  meta() {
+    return fetchHyperliquidMeta(this.environment);
+  }
+  metaAndAssetCtxs() {
+    return fetchHyperliquidMetaAndAssetCtxs(this.environment);
+  }
+  spotMeta() {
+    return fetchHyperliquidSpotMeta(this.environment);
+  }
+  spotMetaAndAssetCtxs() {
+    return fetchHyperliquidSpotMetaAndAssetCtxs(this.environment);
+  }
+  assetCtxs() {
+    return fetchHyperliquidAssetCtxs(this.environment);
+  }
+  spotAssetCtxs() {
+    return fetchHyperliquidSpotAssetCtxs(this.environment);
+  }
+  openOrders(user) {
+    return fetchHyperliquidOpenOrders({ user, environment: this.environment });
+  }
+  frontendOpenOrders(user) {
+    return fetchHyperliquidFrontendOpenOrders({
+      user,
+      environment: this.environment
+    });
+  }
+  orderStatus(user, oid) {
+    return fetchHyperliquidOrderStatus({
+      user,
+      oid,
+      environment: this.environment
+    });
+  }
+  historicalOrders(user) {
+    return fetchHyperliquidHistoricalOrders({
+      user,
+      environment: this.environment
+    });
+  }
+  userFills(user) {
+    return fetchHyperliquidUserFills({ user, environment: this.environment });
+  }
+  userFillsByTime(user, startTime, endTime) {
+    return fetchHyperliquidUserFillsByTime({
+      user,
+      startTime,
+      endTime,
+      environment: this.environment
+    });
+  }
+  userRateLimit(user) {
+    return fetchHyperliquidUserRateLimit({
+      user,
+      environment: this.environment
+    });
+  }
+  preTransferCheck(user, source) {
+    return fetchHyperliquidPreTransferCheck({
+      user,
+      source,
+      environment: this.environment
+    });
+  }
+  spotClearinghouseState(user) {
+    return fetchHyperliquidSpotClearinghouseState({
+      user,
+      environment: this.environment
+    });
+  }
+};
+async function fetchHyperliquidMeta(environment = "mainnet") {
+  return postInfo(environment, { type: "meta" });
+}
+async function fetchHyperliquidMetaAndAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "metaAndAssetCtxs" });
+}
+async function fetchHyperliquidSpotMeta(environment = "mainnet") {
+  return postInfo(environment, { type: "spotMeta" });
+}
+async function fetchHyperliquidSpotMetaAndAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "spotMetaAndAssetCtxs" });
+}
+async function fetchHyperliquidAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "assetCtxs" });
+}
+async function fetchHyperliquidSpotAssetCtxs(environment = "mainnet") {
+  return postInfo(environment, { type: "spotAssetCtxs" });
+}
+async function fetchHyperliquidOpenOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, { type: "openOrders", user: normalizeAddress(params.user) });
+}
+async function fetchHyperliquidFrontendOpenOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "frontendOpenOrders",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidOrderStatus(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "orderStatus",
+    user: normalizeAddress(params.user),
+    oid: params.oid
+  });
+}
+async function fetchHyperliquidHistoricalOrders(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "historicalOrders",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidUserFills(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userFills",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidUserFillsByTime(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userFillsByTime",
+    user: normalizeAddress(params.user),
+    startTime: params.startTime,
+    endTime: params.endTime
+  });
+}
+async function fetchHyperliquidUserRateLimit(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "userRateLimit",
+    user: normalizeAddress(params.user)
+  });
+}
+async function fetchHyperliquidPreTransferCheck(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "preTransferCheck",
+    user: normalizeAddress(params.user),
+    source: normalizeAddress(params.source)
+  });
+}
+async function fetchHyperliquidSpotClearinghouseState(params) {
+  const env = params.environment ?? "mainnet";
+  return postInfo(env, {
+    type: "spotClearinghouseState",
+    user: normalizeAddress(params.user)
+  });
+}
+
+// src/adapters/hyperliquid/index.ts
+async function placeHyperliquidOrder(options) {
+  const {
+    wallet: wallet2,
+    orders,
+    grouping = "na",
+    environment,
+    vaultAddress,
+    expiresAfter,
+    nonce
+  } = options;
+  const effectiveBuilder = BUILDER_CODE;
+  if (!wallet2?.account || !wallet2.walletClient) {
+    throw new Error(
+      "Hyperliquid order signing requires a wallet with signing capabilities."
+    );
+  }
+  if (!orders.length) {
+    throw new Error("At least one order is required.");
+  }
+  const inferredEnvironment = environment ?? "mainnet";
+  const resolvedBaseUrl = API_BASES[inferredEnvironment];
+  const universe = await getUniverse({
+    baseUrl: resolvedBaseUrl,
+    environment: inferredEnvironment,
+    fetcher: fetch
+  });
+  const preparedOrders = orders.map((intent) => {
+    const assetIndex = resolveAssetIndex(intent.symbol, universe);
+    const limitOrTrigger = intent.trigger ? {
+      trigger: {
+        isMarket: Boolean(intent.trigger.isMarket),
+        triggerPx: toApiDecimal(intent.trigger.triggerPx),
+        tpsl: intent.trigger.tpsl
+      }
+    } : {
+      limit: {
+        tif: intent.tif ?? "Ioc"
+      }
+    };
+    const order = {
+      a: assetIndex,
+      b: intent.side === "buy",
+      p: toApiDecimal(intent.price),
+      s: toApiDecimal(intent.size),
+      r: intent.reduceOnly ?? false,
+      t: limitOrTrigger,
+      ...intent.clientId ? {
+        c: normalizeHex(intent.clientId)
+      } : {}
+    };
+    return order;
+  });
+  const action = {
+    type: "order",
+    orders: preparedOrders,
+    grouping
+  };
+  if (effectiveBuilder) {
+    action.builder = {
+      b: normalizeAddress(effectiveBuilder.address),
+      f: effectiveBuilder.fee
+    };
+  }
+  const effectiveNonce = nonce ?? Date.now();
+  const signature = await signL1Action({
+    wallet: wallet2,
+    action,
+    nonce: effectiveNonce,
+    ...vaultAddress ? { vaultAddress } : {},
+    ...typeof expiresAfter === "number" ? { expiresAfter } : {},
+    isTestnet: inferredEnvironment === "testnet"
+  });
+  const body = {
+    action,
+    nonce: effectiveNonce,
+    signature
+  };
+  if (vaultAddress) {
+    body.vaultAddress = normalizeAddress(vaultAddress);
+  }
+  if (typeof expiresAfter === "number") {
+    body.expiresAfter = expiresAfter;
+  }
+  const response = await fetch(`${resolvedBaseUrl}/exchange`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const rawText = await response.text().catch(() => null);
+  let parsed = null;
+  if (rawText && rawText.length) {
+    try {
+      parsed = JSON.parse(rawText);
+    } catch {
+      parsed = rawText;
+    }
+  }
+  const json = parsed && typeof parsed === "object" && "status" in parsed ? parsed : null;
+  if (!response.ok || !json) {
+    const detail = parsed?.error ?? parsed?.message ?? (typeof parsed === "string" ? parsed : rawText);
+    const suffix = detail ? ` Detail: ${detail}` : "";
+    throw new HyperliquidApiError(
+      `Failed to submit Hyperliquid order.${suffix}`,
+      parsed ?? rawText ?? { status: response.status }
+    );
+  }
+  if (json.status !== "ok") {
+    const detail = parsed?.error ?? rawText;
+    throw new HyperliquidApiError(
+      detail ? `Hyperliquid API returned an error status: ${detail}` : "Hyperliquid API returned an error status.",
+      json
+    );
+  }
+  const statuses = json.response?.data?.statuses ?? [];
+  const errorStatuses = statuses.filter(
+    (entry) => "error" in entry
+  );
+  if (errorStatuses.length) {
+    const message = errorStatuses.map((entry) => entry.error).join(", ");
+    throw new HyperliquidApiError(
+      message || "Hyperliquid rejected the order.",
+      json
+    );
+  }
+  return json;
+}
+async function depositToHyperliquidBridge(options) {
+  const { environment, amount, wallet: wallet2 } = options;
+  const parsedAmount = Number(amount);
+  if (!Number.isFinite(parsedAmount) || parsedAmount <= 0) {
+    throw new Error("Deposit amount must be a positive number.");
+  }
+  if (parsedAmount < MIN_DEPOSIT_USDC) {
+    throw new Error(`Minimum deposit is ${MIN_DEPOSIT_USDC} USDC.`);
+  }
+  if (!wallet2.account || !wallet2.walletClient) {
+    throw new Error("Wallet with signing capability is required for deposit.");
+  }
+  const bridgeAddress = getBridgeAddress(environment);
+  const usdcAddress = getUsdcAddress(environment);
+  const amountUnits = parseUnits(amount, 6);
+  if (!wallet2.walletClient || !wallet2.publicClient) {
+    throw new Error(
+      "Wallet client and public client are required for deposit."
+    );
+  }
+  const walletClient = wallet2.walletClient;
+  const publicClient = wallet2.publicClient;
+  const data = encodeFunctionData({
+    abi: erc20Abi,
+    functionName: "transfer",
+    args: [bridgeAddress, amountUnits]
+  });
+  const txHash = await walletClient.sendTransaction({
+    account: wallet2.account,
+    to: usdcAddress,
+    data
+  });
+  await publicClient.waitForTransactionReceipt({ hash: txHash });
+  return {
+    txHash,
+    amount: parsedAmount,
+    amountUnits: amountUnits.toString(),
+    environment,
+    bridgeAddress
+  };
+}
+async function withdrawFromHyperliquid(options) {
+  const { environment, amount, destination, wallet: wallet2 } = options;
+  const parsedAmount = Number(amount);
+  if (!Number.isFinite(parsedAmount) || parsedAmount <= 0) {
+    throw new Error("Withdraw amount must be a positive number.");
+  }
+  if (!wallet2.account || !wallet2.walletClient || !wallet2.publicClient) {
+    throw new Error(
+      "Wallet client and public client are required for withdraw."
+    );
+  }
+  const signatureChainId = getSignatureChainId(environment);
+  const hyperliquidChain = HL_CHAIN_LABEL[environment];
+  const domain = {
+    name: "HyperliquidSignTransaction",
+    version: "1",
+    chainId: Number.parseInt(signatureChainId, 16),
+    verifyingContract: ZERO_ADDRESS
+  };
+  const time = BigInt(Date.now());
+  const nonce = Number(time);
+  const normalizedDestination = normalizeAddress(destination);
+  const message = {
+    hyperliquidChain,
+    destination: normalizedDestination,
+    amount: parsedAmount.toString(),
+    time
+  };
+  const types = {
+    "HyperliquidTransaction:Withdraw": [
+      { name: "hyperliquidChain", type: "string" },
+      { name: "destination", type: "string" },
+      { name: "amount", type: "string" },
+      { name: "time", type: "uint64" }
+    ]
+  };
+  const signatureHex = await wallet2.walletClient.signTypedData({
+    account: wallet2.account,
+    domain,
+    types,
+    primaryType: "HyperliquidTransaction:Withdraw",
+    message
+  });
+  const signature = splitSignature(signatureHex);
+  const payload = {
+    action: {
+      type: "withdraw3",
+      signatureChainId,
+      hyperliquidChain,
+      destination: normalizedDestination,
+      amount: parsedAmount.toString(),
+      time: nonce
+    },
+    nonce,
+    signature
+  };
+  const endpoint = `${HL_ENDPOINT[environment]}/exchange`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const json = await response.json().catch(() => null);
+  if (!response.ok || json?.status !== "ok") {
+    throw new Error(
+      `Hyperliquid withdraw failed: ${json?.response ?? json?.error ?? response.statusText}`
+    );
+  }
+  return {
+    amount: parsedAmount,
+    destination: normalizedDestination,
+    environment,
+    nonce,
+    status: json.status ?? "ok"
+  };
+}
+async function fetchHyperliquidClearinghouseState(params) {
+  const { environment, walletAddress } = params;
+  const response = await fetch(`${HL_ENDPOINT[environment]}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ type: "clearinghouseState", user: walletAddress })
+  });
+  const data = await response.json().catch(() => null);
+  return {
+    ok: response.ok,
+    data
+  };
+}
+async function approveHyperliquidBuilderFee(options) {
+  const { environment, wallet: wallet2, nonce, signatureChainId } = options;
+  if (!wallet2?.account || !wallet2.walletClient) {
+    throw new Error(
+      "Hyperliquid builder approval requires a wallet with signing capabilities."
+    );
+  }
+  const maxFeeRateValue = BUILDER_CODE.fee / 1e3;
+  const formattedPercent = `${maxFeeRateValue}%`;
+  const normalizedBuilder = normalizeAddress(BUILDER_CODE.address);
+  const inferredEnvironment = environment ?? "mainnet";
+  const resolvedBaseUrl = API_BASES[inferredEnvironment];
+  const maxFeeRate = formattedPercent;
+  const effectiveNonce = nonce ?? Date.now();
+  const signatureNonce = BigInt(effectiveNonce);
+  const signatureChainHex = signatureChainId ?? getSignatureChainId(inferredEnvironment);
+  const approvalSignature = await signApproveBuilderFee({
+    wallet: wallet2,
+    maxFeeRate,
+    nonce: signatureNonce,
+    signatureChainId: signatureChainHex,
+    isTestnet: inferredEnvironment === "testnet"
+  });
+  const action = {
+    type: "approveBuilderFee",
+    maxFeeRate,
+    builder: normalizedBuilder,
+    hyperliquidChain: HL_CHAIN_LABEL[inferredEnvironment],
+    signatureChainId: signatureChainHex,
+    nonce: effectiveNonce
+  };
+  const payload = {
+    action,
+    nonce: effectiveNonce,
+    signature: approvalSignature
+  };
+  const response = await fetch(`${resolvedBaseUrl}/exchange`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+  const rawText = await response.text().catch(() => null);
+  let parsed = null;
+  if (rawText && rawText.length) {
+    try {
+      parsed = JSON.parse(rawText);
+    } catch {
+      parsed = rawText;
+    }
+  }
+  const json = parsed && typeof parsed === "object" && "status" in parsed ? parsed : null;
+  if (!response.ok || !json) {
+    const detail = parsed?.error ?? parsed?.message ?? (typeof parsed === "string" ? parsed : rawText);
+    const suffix = detail ? ` Detail: ${detail}` : "";
+    throw new HyperliquidApiError(
+      `Failed to submit builder approval.${suffix}`,
+      parsed ?? rawText ?? { status: response.status }
+    );
+  }
+  if (json.status !== "ok") {
+    const detail = parsed?.error ?? rawText;
+    throw new HyperliquidApiError(
+      detail ? `Hyperliquid builder approval returned an error: ${detail}` : "Hyperliquid builder approval returned an error.",
+      json
+    );
+  }
+  return json;
+}
+async function getHyperliquidMaxBuilderFee(params) {
+  const { environment, user } = params;
+  const resolvedBaseUrl = API_BASES[environment];
+  const response = await fetch(`${resolvedBaseUrl}/info`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      type: "maxBuilderFee",
+      user: normalizeAddress(user),
+      builder: BUILDER_CODE.address
+    })
+  });
+  const data = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw new HyperliquidApiError(
+      "Failed to query max builder fee.",
+      data ?? { status: response.status }
+    );
+  }
+  return data;
+}
+async function recordHyperliquidTermsAcceptance(input) {
+  const { environment, walletAddress, storeOptions } = input;
+  return store(
+    {
+      source: "hyperliquid",
+      ref: `${environment}-terms-${Date.now()}`,
+      status: "info",
+      walletAddress,
+      action: "terms",
+      metadata: {
+        environment,
+        note: "Hyperliquid does not expose a terms endpoint; this records local acknowledgement only."
+      }
+    },
+    storeOptions
+  );
+}
+async function recordHyperliquidBuilderApproval(input) {
+  const { environment, walletAddress, storeOptions } = input;
+  const maxFeeRate = `${BUILDER_CODE.fee / 1e3}%`;
+  return store(
+    {
+      source: "hyperliquid",
+      ref: `${environment}-builder-${Date.now()}`,
+      status: "info",
+      walletAddress,
+      action: "builder-approval",
+      metadata: {
+        environment,
+        builder: BUILDER_CODE.address,
+        maxFeeRate
+      }
+    },
+    storeOptions
+  );
+}
+var __hyperliquidInternals = {
+  toApiDecimal,
+  createL1ActionHash,
+  splitSignature
+};
+
 // src/ai/errors.ts
 var AIError = class extends Error {
   constructor(message, options) {
@@ -1607,7 +3100,7 @@ function assertFetchAvailable(fetchImplementation) {
     );
   }
 }
-function resolveConfig(config = {}) {
+function resolveConfig2(config = {}) {
   const fetchImplementation = config.fetchImplementation ?? globalThis.fetch;
   assertFetchAvailable(fetchImplementation);
   const resolved = {
@@ -1848,7 +3341,7 @@ function extractTextPart(part, options) {
 // src/ai/client.ts
 var CHAT_COMPLETIONS_PATH = "/v1/chat/completions";
 function createAIClient(config = {}) {
-  const resolved = resolveConfig(config);
+  const resolved = resolveConfig2(config);
   return {
     get config() {
       return resolved;
@@ -1863,7 +3356,7 @@ function createAIClient(config = {}) {
   };
 }
 async function generateText(options, clientConfig = {}) {
-  const resolved = resolveConfig(clientConfig);
+  const resolved = resolveConfig2(clientConfig);
   const model = normalizeModelName(options.model ?? resolved.defaultModel);
   const payload = buildRequestPayload(options, model, {
     allowTools: isToolCallingSupported(model)
@@ -1929,7 +3422,7 @@ async function generateText(options, clientConfig = {}) {
   return result;
 }
 async function streamText(options, clientConfig = {}) {
-  const resolved = resolveConfig(clientConfig);
+  const resolved = resolveConfig2(clientConfig);
   const model = normalizeModelName(options.model ?? resolved.defaultModel);
   const streamExtras = buildStreamMetadataExtras(options);
   const payload = buildRequestPayload(
@@ -2318,73 +3811,6 @@ function toAbortError(reason) {
   }
   return new AIAbortError(String(reason ?? "AI request aborted"));
 }
-
-// src/store/index.ts
-var StoreError = class extends Error {
-  constructor(message, status, causeData) {
-    super(message);
-    this.status = status;
-    this.causeData = causeData;
-    this.name = "StoreError";
-  }
-};
-function resolveConfig2(options) {
-  const baseUrl = options?.baseUrl ?? process.env.BASE_URL;
-  const apiKey = options?.apiKey ?? process.env.OPENPOND_API_KEY;
-  if (!baseUrl) {
-    throw new StoreError("BASE_URL is required to store activity events");
-  }
-  if (!apiKey) {
-    throw new StoreError(
-      "OPENPOND_API_KEY is required to store activity events"
-    );
-  }
-  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
-  const fetchFn = options?.fetchFn ?? globalThis.fetch;
-  if (!fetchFn) {
-    throw new StoreError("Fetch is not available in this environment");
-  }
-  return { baseUrl: normalizedBaseUrl, apiKey, fetchFn };
-}
-async function store(input, options) {
-  const { baseUrl, apiKey, fetchFn } = resolveConfig2(options);
-  const url = `${baseUrl}/apps/positions/tx`;
-  let response;
-  try {
-    response = await fetchFn(url, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "openpond-api-key": apiKey
-      },
-      body: JSON.stringify(input)
-    });
-  } catch (error) {
-    throw new StoreError("Failed to reach store endpoint", void 0, error);
-  }
-  if (!response.ok) {
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = await response.text().catch(() => void 0);
-    }
-    throw new StoreError(
-      `Store request failed with status ${response.status}`,
-      response.status,
-      body
-    );
-  }
-  try {
-    const data = await response.json();
-    return {
-      id: data.id ?? "",
-      status: data.status ?? null
-    };
-  } catch {
-    return { id: "", status: null };
-  }
-}
 var METADATA_SPEC_VERSION = "1.1.0";
 var McpAnnotationsSchema = z.object({
   title: z.string().optional(),
@@ -2526,7 +3952,7 @@ async function transpileWithEsbuild(options) {
     format: options.format,
     platform: "node",
     target: "node20",
-    logLevel: "warning",
+    logLevel: options.logLevel ?? "warning",
     sourcesContent: false,
     sourcemap: false,
     loader: {
@@ -2540,13 +3966,16 @@ async function transpileWithEsbuild(options) {
       ".cjs": "js",
       ".json": "json"
     },
-    metafile: false,
+    metafile: options.metafile ?? false,
     allowOverwrite: true,
     absWorkingDir: projectRoot
   };
   if (options.external && options.external.length > 0) {
     buildOptions.external = options.external;
   }
+  if (options.outBase) {
+    buildOptions.outbase = options.outBase;
+  }
   if (!buildOptions.bundle) {
     buildOptions.packages = "external";
   }
@@ -2928,11 +4357,8 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         throw new Error(`${file}: export exactly one of GET or POST`);
       }
       let normalizedSchedule = null;
-      if (hasGET) {
-        const schedule = toolModule?.profile?.schedule;
-        if (!schedule || typeof schedule?.cron !== "string" || schedule.cron.trim().length === 0) {
-          throw new Error(`${file}: GET tools require profile.schedule { cron }`);
-        }
+      const schedule = toolModule?.profile?.schedule;
+      if (hasGET && schedule && typeof schedule.cron === "string" && schedule.cron.trim().length > 0) {
         normalizedSchedule = normalizeScheduleExpression(schedule.cron, file);
         if (typeof schedule.enabled === "boolean") {
           normalizedSchedule.authoredEnabled = schedule.enabled;
@@ -2942,6 +4368,9 @@ async function loadAndValidateTools(toolsDir, options = {}) {
         if (!schema) {
           throw new Error(`${file}: POST tools must export a Zod schema as 'schema'`);
         }
+        if (schedule && typeof schedule.cron === "string") {
+          throw new Error(`${file}: POST tools must not define profile.schedule; use GET + cron for scheduled tasks.`);
+        }
       }
       const httpHandlers = [...httpHandlersRaw];
       if (httpHandlers.length === 0) {
@@ -3227,6 +4656,6 @@ function timestamp() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }
 
-export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, PAYMENT_HEADERS, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, chains, createAIClient, createDevServer, createMcpAdapter, createStdioServer, defineX402Payment, ensureTextContent, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getModelConfig, getRpcUrl, getX402PaymentContext, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, normalizeModelName, payX402, payX402WithWallet, registry, requireX402Payment, resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, store, streamText, tokens, validateCommand, wallet, walletToolkit, withX402Payment };
+export { AIAbortError, AIError, AIFetchError, AIResponseError, DEFAULT_BASE_URL, DEFAULT_CHAIN, DEFAULT_FACILITATOR, DEFAULT_MODEL, DEFAULT_TIMEOUT_MS, DEFAULT_TOKENS, HTTP_METHODS2 as HTTP_METHODS, HyperliquidApiError, HyperliquidBuilderApprovalError, HyperliquidExchangeClient, HyperliquidGuardError, HyperliquidInfoClient, HyperliquidTermsError, PAYMENT_HEADERS, SUPPORTED_CURRENCIES, StoreError, WEBSEARCH_TOOL_DEFINITION, WEBSEARCH_TOOL_NAME, X402BrowserClient, X402Client, X402PaymentRequiredError, __hyperliquidInternals, approveHyperliquidBuilderFee, batchModifyHyperliquidOrders, cancelAllHyperliquidOrders, cancelHyperliquidOrders, cancelHyperliquidOrdersByCloid, cancelHyperliquidTwapOrder, chains, createAIClient, createDevServer, createHyperliquidSubAccount, createMcpAdapter, createMonotonicNonceFactory, createStdioServer, defineX402Payment, depositToHyperliquidBridge, ensureTextContent, fetchHyperliquidAssetCtxs, fetchHyperliquidClearinghouseState, fetchHyperliquidFrontendOpenOrders, fetchHyperliquidHistoricalOrders, fetchHyperliquidMeta, fetchHyperliquidMetaAndAssetCtxs, fetchHyperliquidOpenOrders, fetchHyperliquidOrderStatus, fetchHyperliquidPreTransferCheck, fetchHyperliquidSpotAssetCtxs, fetchHyperliquidSpotClearinghouseState, fetchHyperliquidSpotMeta, fetchHyperliquidSpotMetaAndAssetCtxs, fetchHyperliquidUserFills, fetchHyperliquidUserFillsByTime, fetchHyperliquidUserRateLimit, flattenMessageContent, generateMetadata, generateMetadataCommand, generateText, getHyperliquidMaxBuilderFee, getModelConfig, getRpcUrl, getX402PaymentContext, isStreamingSupported, isToolCallingSupported, listModels, loadAndValidateTools, modifyHyperliquidOrder, normalizeModelName, payX402, payX402WithWallet, placeHyperliquidOrder, placeHyperliquidTwapOrder, recordHyperliquidBuilderApproval, recordHyperliquidTermsAcceptance, registry, requireX402Payment, reserveHyperliquidRequestWeight, resolveConfig2 as resolveConfig, resolveRuntimePath, resolveToolset, responseToToolResponse, retrieve, scheduleHyperliquidCancel, sendHyperliquidSpot, store, streamText, tokens, transferHyperliquidSubAccount, updateHyperliquidIsolatedMargin, updateHyperliquidLeverage, validateCommand, wallet, walletToolkit, withX402Payment, withdrawFromHyperliquid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map