@forgezero/providers 0.1.23 → 0.1.25

package/dist/binance.js

@@ -1,704 +0,0 @@
-// src/index.ts
-class ProviderError extends Error {
-  code;
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.code = code;
-    this.details = details;
-    this.name = "ProviderError";
-  }
-}
-function envCredentials(env) {
-  return {
-    name: "env",
-    async get(reference, field) {
-      const key = `${reference}_${field}`.replace(/[.-]/g, "_").toUpperCase();
-      const value = env[key];
-      if (value === undefined) {
-        throw new ProviderError("CREDENTIAL_MISSING", `Set ${key} in the environment.`);
-      }
-      return value;
-    }
-  };
-}
-function chainCredentials(...sources) {
-  return {
-    name: sources.map((source) => source.name).join("+"),
-    async get(reference, field) {
-      let last;
-      for (const source of sources) {
-        try {
-          return await source.get(reference, field);
-        } catch (error) {
-          last = error;
-        }
-      }
-      throw last instanceof Error ? last : new ProviderError("CREDENTIAL_MISSING", `No source held ${reference}.${field}.`);
-    }
-  };
-}
-function scopeCredentials(source, reference) {
-  return {
-    name: `${source.name}:${reference}`,
-    get: (field) => source.get(reference, field)
-  };
-}
-function chainScopedCredentials(...sources) {
-  return {
-    name: sources.map((source) => source.name).join("+"),
-    async get(field) {
-      let last;
-      for (const source of sources) {
-        try {
-          return await source.get(field);
-        } catch (error) {
-          last = error;
-        }
-      }
-      throw last instanceof Error ? last : new ProviderError("CREDENTIAL_MISSING", `No scoped source held field "${field}".`);
-    }
-  };
-}
-function staticConfig(config) {
-  const providers = new Map(config.providers.map((provider) => [provider.instanceKey, provider]));
-  if (providers.size !== config.providers.length) {
-    throw new ProviderError("CONFIG_DUPLICATE_INSTANCE", "Provider instance keys must be unique.");
-  }
-  const health = new Map;
-  return {
-    name: "static",
-    async provider(instanceKey) {
-      const provider = providers.get(instanceKey);
-      return provider ? { ...provider, config: { ...provider.config } } : undefined;
-    },
-    async list(serviceKey, methodKey) {
-      return (config.services[serviceKey]?.[methodKey] ?? []).map((attachment) => ({
-        ...attachment,
-        health: health.get(`${serviceKey}:${methodKey}:${attachment.instanceKey}:${attachment.providerMethod}:${attachment.providerMethodVersion ?? "current"}`) ?? (attachment.providerMethodVersion === undefined ? [...health.entries()].find(([key]) => key.startsWith(`${serviceKey}:${methodKey}:${attachment.instanceKey}:${attachment.providerMethod}:`))?.[1] : undefined) ?? attachment.health
-      }));
-    },
-    async recordHealth(serviceKey, methodKey, instanceKey, providerMethod, providerMethodVersion, next) {
-      health.set(`${serviceKey}:${methodKey}:${instanceKey}:${providerMethod}:${providerMethodVersion}`, next);
-    }
-  };
-}
-function defineProviderMethod(method) {
-  return method;
-}
-function defineProviderMethodBranches(branches) {
-  const entries = Object.entries(branches.versions);
-  if (entries.length === 0 || !branches.versions[branches.currentVersion]) {
-    throw new ProviderError("PROVIDER_METHOD_VERSION", "A versioned provider method needs a current branch.");
-  }
-  for (const [version, method] of entries) {
-    if (method.version !== version) {
-      throw new ProviderError("PROVIDER_METHOD_VERSION", `Provider method branch "${version}" declares version "${method.version}".`);
-    }
-    if (version === branches.currentVersion && method.lifecycle !== "current") {
-      throw new ProviderError("PROVIDER_METHOD_VERSION", `Current provider method branch "${version}" must have lifecycle current.`);
-    }
-  }
-  return branches;
-}
-var methodBranch = (provider, methodName, version) => {
-  const entry = provider?.methods[methodName];
-  if (!entry)
-    return;
-  if ("versions" in entry)
-    return entry.versions[version ?? entry.currentVersion];
-  return version === undefined || version === entry.version ? entry : undefined;
-};
-function defineProvider(spec) {
-  for (const [name, entry] of Object.entries(spec.methods)) {
-    if ("versions" in entry)
-      defineProviderMethodBranches(entry);
-    else if (!entry.version || !["current", "legacy", "deprecated", "retired"].includes(entry.lifecycle)) {
-      throw new ProviderError("PROVIDER_METHOD_VERSION", `Provider method "${spec.id}.${name}" needs a version and lifecycle.`);
-    }
-  }
-  return spec;
-}
-function defineSingleMethodProvider(spec) {
-  const { method, version = "v1", lifecycle = "current", invoke, classify, ...identity } = spec;
-  return defineProvider({
-    ...identity,
-    methods: { [method]: defineProviderMethod({ version, lifecycle, invoke, classify }) }
-  });
-}
-var STRIKES_TO_OFFLINE = 3;
-function serviceMethod() {
-  return Object.freeze({});
-}
-function defineService(definition) {
-  return definition;
-}
-function nextHealth(current, kind) {
-  if (kind === "success")
-    return { strikes: 0, status: "ok" };
-  if (kind === "backoff")
-    return current ?? { strikes: 0, status: "ok" };
-  const strikes = (current?.strikes ?? 0) + 1;
-  return {
-    strikes,
-    status: strikes >= STRIKES_TO_OFFLINE ? "offline" : "degraded",
-    lastFailureAtTs: Date.now()
-  };
-}
-function createRegistry(options) {
-  const byId = new Map(options.providers.map((provider) => [provider.id, provider]));
-  async function call(serviceKey, methodKey, args, callOptions = {}) {
-    const configured = [...await options.config.list(serviceKey, methodKey)].filter((attachment) => attachment.enabled).sort((a, b) => a.priority - b.priority);
-    const attempts = [];
-    for (const attachment of configured) {
-      const requestedVersion = attachment.providerMethodVersion;
-      if (callOptions.signal?.aborted) {
-        const cancelled = {
-          ok: false,
-          fallbackUsed: attempts.length > 0,
-          attempts,
-          error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
-        };
-        await options.after?.(cancelled);
-        return cancelled;
-      }
-      const instance = await options.config.provider(attachment.instanceKey);
-      if (!instance) {
-        attempts.push({ providerId: "unknown", instanceKey: attachment.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: requestedVersion ?? "current", outcome: "skipped", error: "instance not registered" });
-        continue;
-      }
-      const spec = byId.get(instance.providerId);
-      const method = methodBranch(spec, attachment.providerMethod, requestedVersion);
-      if (!spec || !method) {
-        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: requestedVersion ?? "current", outcome: "skipped", error: !spec ? "provider not registered" : "method version not supported" });
-        continue;
-      }
-      if (method.lifecycle === "retired") {
-        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: method.version, outcome: "skipped", error: "method version retired" });
-        continue;
-      }
-      if (!instance.enabled) {
-        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: method.version, outcome: "skipped", error: "instance disabled" });
-        continue;
-      }
-      if (attachment.health?.status === "offline") {
-        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: method.version, outcome: "skipped", error: "offline" });
-        continue;
-      }
-      await options.before?.({ service: serviceKey, method: methodKey, provider: instance.providerId, instance: instance.instanceKey });
-      const startedAt = performance.now();
-      try {
-        const result = await method.invoke({
-          config: instance.config,
-          secret: (field) => options.credentials.get(instance.secretRef, field),
-          signal: callOptions.signal
-        }, args);
-        attempts.push({ providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: method.version, outcome: "sent", durationMs: performance.now() - startedAt });
-        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, method.version, nextHealth(attachment.health, "success"));
-        const sent = {
-          ok: true,
-          result,
-          provider: instance.providerId,
-          instance: instance.instanceKey,
-          method: attachment.providerMethod,
-          selected: { providerId: instance.providerId, instanceKey: instance.instanceKey, providerMethod: attachment.providerMethod, providerMethodVersion: method.version },
-          fallbackUsed: attempts.length > 1,
-          attempts
-        };
-        await options.after?.(sent);
-        return sent;
-      } catch (error) {
-        if (callOptions.signal?.aborted) {
-          const cancelled = {
-            ok: false,
-            fallbackUsed: attempts.length > 0,
-            attempts,
-            error: new ProviderError("CALL_ABORTED", `The "${serviceKey}.${methodKey}" call was cancelled.`)
-          };
-          await options.after?.(cancelled);
-          return cancelled;
-        }
-        const kind = method.classify(error);
-        const message = error instanceof Error ? error.message : String(error);
-        const code = error instanceof ProviderError ? error.code : typeof error?.code === "string" ? error.code : undefined;
-        attempts.push({
-          providerId: instance.providerId,
-          instanceKey: instance.instanceKey,
-          providerMethod: attachment.providerMethod,
-          providerMethodVersion: method.version,
-          outcome: "failed",
-          kind,
-          durationMs: performance.now() - startedAt,
-          failure: { kind, ...code ? { code } : {}, message },
-          error: message
-        });
-        await options.config.recordHealth(serviceKey, methodKey, instance.instanceKey, attachment.providerMethod, method.version, nextHealth(attachment.health, kind));
-        if (kind === "terminal") {
-          const refused = {
-            ok: false,
-            fallbackUsed: attempts.length > 1,
-            attempts,
-            error: new ProviderError("PAYLOAD_REJECTED", "The request was refused as malformed; no provider will accept it.")
-          };
-          await options.after?.(refused);
-          return refused;
-        }
-      }
-    }
-    const failed = {
-      ok: false,
-      fallbackUsed: attempts.length > 1,
-      attempts,
-      error: new ProviderError(attempts.length === 0 ? "NO_PROVIDER" : "ALL_PROVIDERS_FAILED", attempts.length === 0 ? `No provider method is configured for "${serviceKey}.${methodKey}".` : `Every provider method for "${serviceKey}.${methodKey}" failed or was skipped.`)
-    };
-    await options.after?.(failed);
-    return failed;
-  }
-  function service(definition) {
-    return {
-      call(method, args, callOptions) {
-        return call(definition.key, method, args, callOptions);
-      }
-    };
-  }
-  return { call, service };
-}
-function createService(definition, methods, options = {}) {
-  const providers = new Map;
-  const credentials = new Map;
-  const instances = [];
-  const serviceMethods = {};
-  for (const methodKey of Object.keys(definition.methods)) {
-    const attachments = methods[methodKey];
-    if (!Array.isArray(attachments)) {
-      throw new ProviderError("CONFIG_METHOD_MISSING", `Service method "${definition.key}.${methodKey}" needs an attachment array.`);
-    }
-    const priorities = new Set;
-    serviceMethods[methodKey] = attachments.map((attachment, index) => {
-      if (!Number.isInteger(attachment.priority) || attachment.priority < 1 || attachment.priority > 1000) {
-        throw new ProviderError("CONFIG_PRIORITY", `Priority for "${definition.key}.${methodKey}" must be an integer from 1 to 1000.`);
-      }
-      if (priorities.has(attachment.priority)) {
-        throw new ProviderError("CONFIG_PRIORITY_DUPLICATE", `Priorities for "${definition.key}.${methodKey}" must be unique.`);
-      }
-      priorities.add(attachment.priority);
-      const branch = methodBranch(attachment.provider, attachment.method, attachment.version);
-      if (!branch || branch.lifecycle === "retired") {
-        throw new ProviderError("CONFIG_METHOD_UNSUPPORTED", `Provider "${attachment.provider.id}" does not support active method "${attachment.method}@${attachment.version ?? "current"}".`);
-      }
-      const existing = providers.get(attachment.provider.id);
-      if (existing && existing !== attachment.provider) {
-        throw new ProviderError("CONFIG_PROVIDER_DUPLICATE", `Provider id "${attachment.provider.id}" has more than one definition.`);
-      }
-      providers.set(attachment.provider.id, attachment.provider);
-      const internalKey = `${definition.key}:${methodKey}:${index}`;
-      credentials.set(internalKey, attachment.credentials);
-      instances.push({
-        instanceKey: internalKey,
-        providerId: attachment.provider.id,
-        enabled: attachment.enabled ?? true,
-        config: { ...attachment.config ?? {} },
-        secretRef: internalKey
-      });
-      return {
-        instanceKey: internalKey,
-        providerMethod: attachment.method,
-        providerMethodVersion: branch.version,
-        priority: attachment.priority,
-        enabled: attachment.enabled ?? true
-      };
-    });
-  }
-  const registry = createRegistry({
-    providers: [...providers.values()],
-    config: staticConfig({ providers: instances, services: { [definition.key]: serviceMethods } }),
-    credentials: {
-      name: [...new Set([...credentials.values()].map((source) => source.name))].join("+"),
-      async get(reference, field) {
-        const source = credentials.get(reference);
-        if (!source)
-          throw new ProviderError("CREDENTIAL_SOURCE_MISSING", "The provider credential source is unavailable.");
-        return source.get(field);
-      }
-    },
-    ...options
-  });
-  const dynamic = registry.service(definition);
-  return {
-    async call(method, args, callOptions) {
-      const result = await dynamic.call(method, args, callOptions);
-      const { instance: _instance, selected, attempts, ...rest } = result;
-      return {
-        ...rest,
-        ...selected ? { selected: { providerId: selected.providerId, providerMethod: selected.providerMethod, providerMethodVersion: selected.providerMethodVersion } } : {},
-        attempts: attempts.map(({ instanceKey: _instanceKey, ...attempt }) => attempt)
-      };
-    }
-  };
-}
-var VERSION = "0.1.23";
-
-// src/http.ts
-class BudgetExhausted extends ProviderError {
-  host;
-  retryAfterMs;
-  constructor(host, retryAfterMs) {
-    super("RATE_BUDGET_EXHAUSTED", `The ${host} budget is spent. Retry in ${retryAfterMs}ms.`);
-    this.host = host;
-    this.retryAfterMs = retryAfterMs;
-  }
-}
-var windows = new Map;
-function resetBudgets() {
-  windows.clear();
-}
-function spend(budget, cost, nowMs) {
-  const ceiling = Math.floor(budget.limit * (budget.headroom ?? 0.9));
-  const current = windows.get(budget.host);
-  if (!current || current.resetAtMs <= nowMs) {
-    windows.set(budget.host, { spent: cost, resetAtMs: nowMs + budget.windowMs });
-    return;
-  }
-  if (current.spent + cost > ceiling) {
-    throw new BudgetExhausted(budget.host, current.resetAtMs - nowMs);
-  }
-  current.spent += cost;
-}
-function settle(host, reserved, actual) {
-  const current = windows.get(host);
-  if (!current)
-    return;
-  current.spent = Math.max(0, current.spent - reserved + actual);
-}
-var budgetState = (host) => windows.get(host);
-function createHttpClient(config) {
-  const doFetch = config.fetch ?? globalThis.fetch;
-  const timeoutMs = config.timeoutMs ?? 1e4;
-  return {
-    async call(request) {
-      const reserved = request.weight ?? config.budget.defaultCost;
-      spend(config.budget, reserved, Date.now());
-      const url = new URL(config.baseUrl + request.path);
-      for (const [key, value] of Object.entries(request.query ?? {})) {
-        url.searchParams.set(key, String(value));
-      }
-      const controller = new AbortController;
-      const timer = setTimeout(() => controller.abort(), timeoutMs);
-      try {
-        const response = await doFetch(url.toString(), {
-          method: request.method ?? "GET",
-          signal: controller.signal,
-          headers: {
-            ...request.body === undefined ? {} : { "content-type": "application/json" },
-            ...request.headers
-          },
-          ...request.body === undefined ? {} : { body: JSON.stringify(request.body) }
-        });
-        const cost = config.costOf?.(response);
-        if (cost !== undefined)
-          settle(config.budget.host, reserved, cost);
-        const text = await response.text();
-        let body;
-        try {
-          body = text ? JSON.parse(text) : null;
-        } catch {
-          body = text;
-        }
-        if (!response.ok) {
-          throw Object.assign(new Error(`${config.budget.host} ${response.status}`), {
-            status: response.status,
-            body,
-            retryAfter: response.headers.get("retry-after")
-          });
-        }
-        return { status: response.status, body, cost };
-      } finally {
-        clearTimeout(timer);
-      }
-    },
-    budget: () => budgetState(config.budget.host)
-  };
-}
-var http = defineSingleMethodProvider({
-  id: "http",
-  method: "request",
-  label: "HTTP",
-  multiInstance: true,
-  credentials: {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      apiKey: { type: "string", title: "API key", writeOnly: true },
-      apiSecret: { type: "string", title: "API secret", writeOnly: true }
-    }
-  },
-  config: {
-    type: "object",
-    additionalProperties: false,
-    required: ["baseUrl"],
-    properties: {
-      baseUrl: { type: "string", title: "Base URL" },
-      limit: { type: "integer", default: 6000, title: "Units per window" },
-      windowMs: { type: "integer", default: 60000 },
-      headroom: {
-        type: "number",
-        default: 0.9,
-        description: "Stop at this fraction of the limit. The venue's window boundary is not ours, and the penalty for crossing is a ban rather than a rejection."
-      }
-    }
-  },
-  async invoke(context, request) {
-    const config = context.config;
-    const client = createHttpClient({
-      baseUrl: config.baseUrl,
-      fetch: config.fetch,
-      costOf: config.costOf,
-      budget: {
-        host: new URL(config.baseUrl).host,
-        limit: config.limit ?? 6000,
-        windowMs: config.windowMs ?? 60000,
-        defaultCost: 1,
-        headroom: config.headroom
-      }
-    });
-    return client.call(request);
-  },
-  classify(error) {
-    const status = error.status;
-    if (status === 418)
-      return "backoff";
-    if (status === 429)
-      return "backoff";
-    if (status === 400 || status === 422)
-      return "terminal";
-    if (status === 401 || status === 403)
-      return "retryable";
-    return "retryable";
-  }
-});
-var binanceWeight = (response) => {
-  const header = response.headers.get("x-mbx-used-weight-1m");
-  return header === null ? undefined : Number(header);
-};
-var httpProviders = [http];
-
-// src/binance.ts
-import { parseAmount, formatAmount, zero, assetSpec } from "@forgezero/runtime/finance/money";
-import {
-  parseSymbol,
-  VenueError
-} from "@forgezero/runtime/finance/venues";
-var BUDGET_HOST = "binance";
-var DEFAULT_HOSTS = {
-  spot: "https://api.binance.com",
-  margin: "https://api.binance.com",
-  futures: "https://fapi.binance.com"
-};
-var binanceSymbol = (symbol) => {
-  const { base, quote } = parseSymbol(symbol);
-  return `${base}${quote}`;
-};
-var PATHS = {
-  spot: {
-    order: "/api/v3/order",
-    openOrders: "/api/v3/openOrders",
-    account: "/api/v3/account",
-    exchangeInfo: "/api/v3/exchangeInfo"
-  },
-  margin: {
-    order: "/sapi/v1/margin/order",
-    openOrders: "/sapi/v1/margin/openOrders",
-    account: "/sapi/v1/margin/account",
-    exchangeInfo: "/api/v3/exchangeInfo"
-  },
-  futures: {
-    order: "/fapi/v1/order",
-    openOrders: "/fapi/v1/openOrders",
-    account: "/fapi/v2/account",
-    exchangeInfo: "/fapi/v1/exchangeInfo"
-  }
-};
-function toOrderStatus(status) {
-  switch (status) {
-    case "NEW":
-    case "PENDING_NEW":
-      return "accepted";
-    case "PARTIALLY_FILLED":
-      return "partial";
-    case "FILLED":
-      return "filled";
-    case "CANCELED":
-    case "PENDING_CANCEL":
-    case "EXPIRED":
-    case "EXPIRED_IN_MATCH":
-      return "cancelled";
-    default:
-      return "rejected";
-  }
-}
-var SIDE = { buy: "BUY", sell: "SELL" };
-var TYPE = { market: "MARKET", limit: "LIMIT", "stop-limit": "STOP_LOSS_LIMIT" };
-async function sign(secret, query) {
-  const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-  const mac = await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(query));
-  return [...new Uint8Array(mac)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-function createBinanceAdapter(options) {
-  const hosts = { ...DEFAULT_HOSTS, ...options.hosts };
-  const recvWindow = options.recvWindowMs ?? 5000;
-  const now = options.now ?? Date.now;
-  const clients = new Map;
-  const clientFor = (type) => {
-    const base = hosts[type];
-    const existing = clients.get(base);
-    if (existing)
-      return existing;
-    const client = createHttpClient({
-      baseUrl: base,
-      fetch: options.fetch,
-      costOf: binanceWeight,
-      budget: { host: BUDGET_HOST, limit: 6000, windowMs: 60000, defaultCost: 1, headroom: 0.9 }
-    });
-    clients.set(base, client);
-    return client;
-  };
-  async function signed(args) {
-    const entries = Object.entries(args.params).filter(([, value]) => value !== undefined);
-    const base = new URLSearchParams(entries.map(([name, value]) => [name, String(value)])).toString();
-    const withTiming = `${base}${base ? "&" : ""}recvWindow=${recvWindow}&timestamp=${now()}`;
-    const signature = await sign(options.credentials.apiSecret, withTiming);
-    const response = await clientFor(args.type).call({
-      path: `${args.path}?${withTiming}&signature=${signature}`,
-      method: args.method,
-      weight: args.weight,
-      headers: { "X-MBX-APIKEY": options.credentials.apiKey }
-    });
-    return response.body;
-  }
-  return {
-    venue: "binance",
-    symbolFor: (symbol) => binanceSymbol(symbol),
-    async markets(type) {
-      const info = await clientFor(type).call({ path: PATHS[type].exchangeInfo, weight: 20 });
-      return (info.body.symbols ?? []).filter((entry) => entry.status === "TRADING").map((entry) => {
-        const filter = (name) => entry.filters.find((candidate) => candidate.filterType === name);
-        return {
-          venue: "binance",
-          type,
-          symbol: `${entry.baseAsset}/${entry.quoteAsset}`,
-          base: entry.baseAsset,
-          quote: entry.quoteAsset,
-          lotStep: filter("LOT_SIZE")?.stepSize ?? "0.00000001",
-          tickStep: filter("PRICE_FILTER")?.tickSize ?? "0.00000001",
-          minNotional: filter("NOTIONAL")?.minNotional ?? filter("MIN_NOTIONAL")?.minNotional ?? "0",
-          ...type === "spot" ? {} : { maxLeverage: 125 }
-        };
-      });
-    },
-    async placeOrder(request, market) {
-      if (request.type === "futures" && request.leverage) {
-        await signed({
-          type: "futures",
-          path: "/fapi/v1/leverage",
-          method: "POST",
-          params: { symbol: binanceSymbol(request.symbol), leverage: request.leverage }
-        });
-      }
-      const raw = await signed({
-        type: request.type,
-        path: PATHS[request.type].order,
-        method: "POST",
-        weight: 1,
-        params: {
-          symbol: binanceSymbol(request.symbol),
-          side: SIDE[request.side],
-          type: TYPE[request.orderType],
-          quantity: formatAmount(request.quantity, { trim: true }),
-          price: request.price ? formatAmount(request.price, { trim: true }) : undefined,
-          stopPrice: request.stopPrice ? formatAmount(request.stopPrice, { trim: true }) : undefined,
-          timeInForce: request.orderType === "market" ? undefined : (request.timeInForce ?? "gtc").toUpperCase(),
-          newClientOrderId: request.clientOrderId,
-          ...request.type === "margin" ? { sideEffectType: "NO_SIDE_EFFECT" } : {},
-          ...request.dryRun ? { test: "true" } : {}
-        }
-      });
-      return readOrder(raw, market);
-    },
-    async cancelOrder(args) {
-      await signed({
-        type: args.type,
-        path: PATHS[args.type].order,
-        method: "DELETE",
-        params: { symbol: binanceSymbol(args.symbol), orderId: args.venueOrderId }
-      });
-    },
-    async openOrders(args) {
-      const raw = await signed({
-        type: args.type,
-        path: PATHS[args.type].openOrders,
-        method: "GET",
-        weight: args.symbol ? 3 : 40,
-        params: { symbol: args.symbol ? binanceSymbol(args.symbol) : undefined }
-      });
-      return (raw ?? []).map((entry) => readOrder(entry, undefined));
-    },
-    async balances(type) {
-      const raw = await signed({ type, path: PATHS[type].account, method: "GET", weight: 10, params: {} });
-      const rows = raw.balances ?? raw.userAssets ?? (raw.assets ?? []).map((entry) => ({ asset: entry.asset, free: entry.availableBalance }));
-      return rows.filter((entry) => Number(entry.free) > 0).map((entry) => {
-        try {
-          return parseAmount(entry.free, entry.asset);
-        } catch {
-          return null;
-        }
-      }).filter((amount) => amount !== null);
-    }
-  };
-}
-function readOrder(raw, market) {
-  const asset = market?.base ?? "BTC";
-  const executed = String(raw.executedQty ?? raw.origQty ?? "0");
-  let filledQuantity;
-  try {
-    filledQuantity = parseAmount(executed, asset);
-  } catch {
-    filledQuantity = zero(asset);
-  }
-  const quoteFilled = Number(raw.cummulativeQuoteQty ?? 0);
-  const filled = Number(executed);
-  return {
-    venueOrderId: String(raw.orderId ?? ""),
-    clientOrderId: raw.clientOrderId ? String(raw.clientOrderId) : undefined,
-    status: toOrderStatus(String(raw.status ?? "NEW")),
-    filledQuantity,
-    ...market && filled > 0 && quoteFilled > 0 ? {
-      averagePrice: (() => {
-        try {
-          return parseAmount((quoteFilled / filled).toFixed(assetSpec(market.quote).decimals), market.quote);
-        } catch {
-          return;
-        }
-      })()
-    } : {},
-    raw
-  };
-}
-function readBinanceError(error) {
-  const body = error.body;
-  if (!body?.code)
-    return;
-  const known = {
-    [-1013]: ["MIN_NOTIONAL", "The order is below the venue minimum, or off its lot or tick step."],
-    [-2010]: ["MIN_NOTIONAL", "Rejected: insufficient balance, or below the minimum."],
-    [-1111]: ["LOT_STEP", "More decimal places than this market accepts."],
-    [-1121]: ["UNKNOWN_MARKET", "That symbol is not traded on this venue."]
-  };
-  const match = known[body.code];
-  return match ? new VenueError(match[0], `${match[1]} (${body.msg})`) : undefined;
-}
-export {
-  toOrderStatus,
-  readBinanceError,
-  createBinanceAdapter,
-  binanceSymbol
-};