@kkkermit/trading212.js 0.1.0 → 0.1.1

package/dist/testing.js

@@ -0,0 +1,642 @@
+import { BASE_URLS, ENDPOINTS, decimalPlaces, Trading212, REDACTED } from './chunk-HQVGPC64.js';
+
+// src/testing/scriptedFetch.ts
+var STATUS_TEXT = {
+  200: "OK",
+  204: "No Content",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  408: "Request Timeout",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+async function recordRequest(input, init) {
+  const url = new URL(input);
+  const headers = {};
+  let authorized = false;
+  new Headers(init.headers).forEach((value, key) => {
+    if (key === "authorization") {
+      authorized = value.length > 0;
+      headers[key] = REDACTED;
+    } else headers[key] = value;
+  });
+  let body = void 0;
+  if (typeof init.body === "string") {
+    try {
+      body = JSON.parse(init.body);
+    } catch {
+      body = init.body;
+    }
+  } else if (init.body !== void 0 && init.body !== null) {
+    body = await new Response(init.body).text();
+  }
+  return {
+    method: init.method ?? "GET",
+    url: url.toString(),
+    path: url.pathname,
+    query: Object.fromEntries(url.searchParams),
+    headers,
+    authorized,
+    body
+  };
+}
+function toResponse(scripted) {
+  const status = scripted.status ?? 200;
+  const headers = new Headers(scripted.headers);
+  let text = null;
+  if (typeof scripted.body === "string") text = scripted.body;
+  else if (scripted.body !== void 0) {
+    text = JSON.stringify(scripted.body);
+    if (!headers.has("content-type")) headers.set("content-type", "application/json");
+  }
+  const nullBody = status === 204 || status === 205 || status === 304;
+  return new Response(nullBody ? null : text, { status, statusText: STATUS_TEXT[status] ?? "", headers });
+}
+function scriptedFetch(steps) {
+  const queue = [...steps];
+  const requests = [];
+  const fetch = async (input, init) => {
+    const request = await recordRequest(input, init);
+    requests.push(request);
+    if (init.signal?.aborted) throw init.signal.reason;
+    const step = queue.shift();
+    if (step === void 0) {
+      throw new Error(`scriptedFetch has no response left for ${request.method} ${request.path}.`);
+    }
+    const outcome = typeof step === "function" ? await step(request) : step;
+    if (outcome instanceof Error) throw outcome;
+    return toResponse(outcome);
+  };
+  return { fetch, requests, pending: () => queue.length };
+}
+function networkError(code = "ECONNRESET") {
+  return new TypeError("fetch failed", { cause: Object.assign(new Error(code), { code }) });
+}
+
+// src/testing/fakeServer.ts
+var FAKE_API_KEY = "fake-trading212-key";
+var FAKE_API_SECRET = "fake-trading212-secret";
+var FAKE_AUTHORIZATION = `Basic ${btoa(`${FAKE_API_KEY}:${FAKE_API_SECRET}`)}`;
+var REPORT_HOST = "https://reports.fake-trading212.invalid";
+var DEFAULT_INSTRUMENTS = [
+  {
+    ticker: "AAPL_US_EQ",
+    name: "Apple",
+    shortName: "AAPL",
+    isin: "US0378331005",
+    currencyCode: "USD",
+    type: "STOCK",
+    workingScheduleId: 1,
+    extendedHours: true,
+    maxOpenQuantity: 1e4,
+    addedOn: "2018-07-12T08:00:00.000Z"
+  },
+  {
+    ticker: "MSFT_US_EQ",
+    name: "Microsoft",
+    shortName: "MSFT",
+    isin: "US5949181045",
+    currencyCode: "USD",
+    type: "STOCK",
+    workingScheduleId: 1,
+    extendedHours: true,
+    maxOpenQuantity: 1e4,
+    addedOn: "2018-07-12T08:00:00.000Z"
+  },
+  {
+    ticker: "TSLA_US_EQ",
+    name: "Tesla",
+    shortName: "TSLA",
+    isin: "US88160R1014",
+    currencyCode: "USD",
+    type: "STOCK",
+    workingScheduleId: 1,
+    extendedHours: true,
+    maxOpenQuantity: 1e4,
+    addedOn: "2018-07-12T08:00:00.000Z"
+  },
+  {
+    ticker: "VUSAl_EQ",
+    name: "Vanguard S&P 500 UCITS ETF",
+    shortName: "VUSA",
+    isin: "IE00B3XXRP09",
+    currencyCode: "GBP",
+    type: "ETF",
+    workingScheduleId: 2,
+    extendedHours: false,
+    maxOpenQuantity: 1e4,
+    addedOn: "2019-02-01T08:00:00.000Z"
+  }
+];
+var DEFAULT_PRICES = {
+  AAPL_US_EQ: 230,
+  MSFT_US_EQ: 420,
+  TSLA_US_EQ: 250,
+  VUSAl_EQ: 95
+};
+function weekOfSessions(from, openUtc, closeUtc) {
+  const events = [];
+  const day = new Date(Date.UTC(from.getUTCFullYear(), from.getUTCMonth(), from.getUTCDate()));
+  for (let offset = -1; offset < 8; offset++) {
+    const date = new Date(day.getTime() + offset * 864e5);
+    const weekday = date.getUTCDay();
+    if (weekday === 0 || weekday === 6) continue;
+    const stamp = date.toISOString().slice(0, 10);
+    events.push(
+      { date: `${stamp}T${openUtc}:00.000Z`, type: "OPEN" },
+      { date: `${stamp}T${closeUtc}:00.000Z`, type: "CLOSE" }
+    );
+  }
+  return events;
+}
+function defaultExchanges(now) {
+  return [
+    { id: 1, name: "NASDAQ", workingSchedules: [{ id: 1, timeEvents: weekOfSessions(now, "14:30", "21:00") }] },
+    {
+      id: 2,
+      name: "London Stock Exchange",
+      workingSchedules: [{ id: 2, timeEvents: weekOfSessions(now, "08:00", "16:30") }]
+    }
+  ];
+}
+var roundMoney = (value) => Math.round(value * 100) / 100;
+var roundShares = (value) => Math.round(value * 1e8) / 1e8;
+var INVALID = "The request is invalid";
+var REFUSED = "Error while placing the order";
+var NOT_FOUND = "Requested entity not found";
+function apiError(status, code, title, detail) {
+  return { status, body: { type: `/api-errors/${code}`, title, status, ...detail !== void 0 && { detail } } };
+}
+var FakeTrading212Server = class {
+  environment;
+  /** Every request the client made, without credentials. */
+  requests = [];
+  /** When false, every order is refused with `market-closed`. */
+  marketOpen = true;
+  /** Trading 212 refuses CSV exports on demo; set this to let the fake offer them anyway. */
+  exportsOnDemo = false;
+  cash;
+  currency;
+  accountId;
+  instruments;
+  prices;
+  holdings = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  orderHistory = [];
+  dividends;
+  transactions;
+  exchanges;
+  reports = [];
+  pies = /* @__PURE__ */ new Map();
+  realisedProfitLoss = 0;
+  #failures = /* @__PURE__ */ new Map();
+  #origin;
+  #nextId = 1e6;
+  #traces = 0;
+  constructor(state = {}, environment = "demo") {
+    this.environment = environment;
+    this.#origin = BASE_URLS[environment];
+    this.cash = state.cash ?? 1e4;
+    this.currency = state.currency ?? "GBP";
+    this.accountId = state.accountId ?? 12345678;
+    this.instruments = (state.instruments ?? DEFAULT_INSTRUMENTS).map((instrument) => ({ ...instrument }));
+    this.prices = new Map(Object.entries({ ...DEFAULT_PRICES, ...state.prices }));
+    this.dividends = [...state.dividends ?? []];
+    this.transactions = [...state.transactions ?? []];
+    this.exchanges = state.exchanges ?? defaultExchanges(/* @__PURE__ */ new Date());
+    for (const holding of state.positions ?? []) {
+      this.holdings.set(holding.ticker, {
+        ticker: holding.ticker,
+        quantity: holding.quantity,
+        averagePrice: holding.averagePrice ?? this.priceOf(holding.ticker),
+        inPies: holding.inPies ?? 0,
+        createdAt: (/* @__PURE__ */ new Date(0)).toISOString()
+      });
+    }
+  }
+  /** Pass this as the client's `fetch`. */
+  fetch = async (input, init) => {
+    if (init.signal?.aborted) throw init.signal.reason;
+    const url = new URL(input);
+    if (url.origin === REPORT_HOST) return this.#download(await recordRequest(input, init));
+    const request = await recordRequest(input, init);
+    this.requests.push(request);
+    const endpoint = this.#match(init.method ?? "GET", url.pathname);
+    if (url.origin !== this.#origin || !endpoint)
+      return toResponse(apiError(404, "not-found", "Not found", "Unknown route"));
+    const failure = this.#failures.get(endpoint.definition.id)?.shift();
+    if (failure && "network" in failure) throw networkError(failure.network);
+    const response = failure ?? this.#traced(this.#authorise(init) ?? this.#route(endpoint.definition.id, request, endpoint.id));
+    const limit = endpoint.definition.rateLimit;
+    return toResponse({
+      ...response,
+      headers: {
+        "x-ratelimit-limit": String(limit.requests),
+        "x-ratelimit-period": String(limit.periodMs / 1e3),
+        "x-ratelimit-remaining": String(limit.requests),
+        "x-ratelimit-used": "0",
+        "x-ratelimit-reset": String(Math.ceil((Date.now() + limit.periodMs) / 1e3)),
+        ...response.headers
+      }
+    });
+  };
+  /** Makes the next call to an endpoint fail. Queue several to fail several calls. */
+  failNext(endpoint, failure) {
+    const queue = this.#failures.get(endpoint) ?? [];
+    queue.push(failure);
+    this.#failures.set(endpoint, queue);
+    return this;
+  }
+  setPrice(ticker, price) {
+    this.prices.set(ticker, price);
+    return this;
+  }
+  priceOf(ticker) {
+    return this.prices.get(ticker) ?? 100;
+  }
+  /** Fills a pending limit or stop order, at its limit price, or `price` if given. */
+  fill(orderId, price) {
+    const pending = this.pending.get(orderId);
+    if (!pending) throw new Error(`The fake has no pending order ${orderId}.`);
+    this.pending.delete(orderId);
+    this.cash += pending.reservedCash;
+    const execution = price ?? pending.order.limitPrice ?? pending.order.stopPrice ?? this.priceOf(pending.order.ticker ?? "");
+    return this.#execute(pending.order, execution);
+  }
+  #traced(response) {
+    const { body } = response;
+    if ((response.status ?? 200) < 400 || typeof body !== "object" || body === null || !("type" in body))
+      return response;
+    return { ...response, body: { ...body, traceId: (this.#traces++).toString(16).padStart(32, "0") } };
+  }
+  #authorise(init) {
+    const authorization = new Headers(init.headers).get("authorization");
+    return authorization === FAKE_AUTHORIZATION ? void 0 : { status: 401, headers: { "content-type": "text/plain; charset=utf-8" }, body: "\n" };
+  }
+  #match(method, path) {
+    for (const definition of Object.values(ENDPOINTS)) {
+      if (definition.method !== method) continue;
+      const pattern = new RegExp(`^${definition.path.replace("{id}", "(\\d+)")}$`);
+      const match = pattern.exec(path);
+      if (match) return { definition, id: match[1] === void 0 ? void 0 : Number(match[1]) };
+    }
+    return void 0;
+  }
+  #instrument(ticker) {
+    return this.instruments.find((instrument) => instrument.ticker === ticker);
+  }
+  #instrumentSummary(ticker) {
+    const instrument = this.#instrument(ticker);
+    return {
+      ticker,
+      name: instrument?.name ?? null,
+      isin: instrument?.isin ?? null,
+      currency: instrument?.currencyCode ?? null
+    };
+  }
+  #reservedShares(ticker) {
+    let reserved = 0;
+    for (const pending of this.pending.values())
+      if (pending.order.ticker === ticker) reserved += pending.reservedShares;
+    return reserved;
+  }
+  position(ticker) {
+    const holding = this.holdings.get(ticker);
+    if (!holding) return void 0;
+    const price = this.priceOf(ticker);
+    const value = roundMoney(holding.quantity * price);
+    const cost = roundMoney(holding.quantity * holding.averagePrice);
+    return {
+      instrument: this.#instrumentSummary(ticker),
+      quantity: holding.quantity,
+      quantityInPies: holding.inPies,
+      quantityAvailableForTrading: roundShares(holding.quantity - holding.inPies - this.#reservedShares(ticker)),
+      averagePricePaid: holding.averagePrice,
+      currentPrice: price,
+      createdAt: holding.createdAt,
+      walletImpact: {
+        currency: this.currency,
+        currentValue: value,
+        totalCost: cost,
+        unrealizedProfitLoss: roundMoney(value - cost),
+        fxImpact: 0
+      }
+    };
+  }
+  #summary() {
+    const positions = [...this.holdings.keys()].flatMap((ticker) => this.position(ticker) ?? []);
+    const currentValue = roundMoney(
+      positions.reduce((total, position) => total + (position.walletImpact?.currentValue ?? 0), 0)
+    );
+    const totalCost = roundMoney(
+      positions.reduce((total, position) => total + (position.walletImpact?.totalCost ?? 0), 0)
+    );
+    const reserved = [...this.pending.values()].reduce((total, pending) => total + pending.reservedCash, 0);
+    return {
+      id: this.accountId,
+      currency: this.currency,
+      totalValue: roundMoney(this.cash + reserved + currentValue),
+      cash: { availableToTrade: roundMoney(this.cash), reservedForOrders: roundMoney(reserved), inPies: 0 },
+      investments: {
+        currentValue,
+        totalCost,
+        realizedProfitLoss: roundMoney(this.realisedProfitLoss),
+        unrealizedProfitLoss: roundMoney(currentValue - totalCost)
+      }
+    };
+  }
+  #route(id, request, pathId) {
+    const body = request.body ?? {};
+    switch (id) {
+      case "getAccountSummary":
+        return { body: this.#summary() };
+      case "listPositions": {
+        const tickers = request.query.ticker ? [request.query.ticker] : [...this.holdings.keys()];
+        return { body: tickers.flatMap((ticker) => this.position(ticker) ?? []) };
+      }
+      case "listInstruments":
+        return { body: this.instruments };
+      case "listExchanges":
+        return { body: this.exchanges };
+      case "listOrders":
+        return { body: [...this.pending.values()].map((pending) => pending.order) };
+      case "getOrder": {
+        const pending = this.pending.get(pathId ?? 0);
+        return pending ? { body: pending.order } : apiError(404, "entity-not-found", NOT_FOUND, "Order not found");
+      }
+      case "cancelOrder":
+        return this.#cancel(pathId ?? 0);
+      case "placeMarketOrder":
+      case "placeLimitOrder":
+      case "placeStopOrder":
+      case "placeStopLimitOrder":
+        return this.#place(id, body);
+      case "listHistoricalOrders":
+        return this.#page(request, this.orderHistory, (item) => item.order?.ticker ?? void 0);
+      case "listDividends":
+        return this.#page(request, this.dividends, (item) => item.ticker ?? void 0);
+      case "listTransactions":
+        return this.#page(request, this.transactions, () => void 0, true);
+      case "listReports":
+        return this.#listReports();
+      case "requestReport":
+        return this.#requestReport(body);
+      case "listPies":
+        return { body: [...this.pies.entries()].map(([pieId, pie]) => this.#pieSummary(pieId, pie.cash)) };
+      case "getPie":
+        return this.#pie(pathId ?? 0);
+      case "createPie": {
+        const pieId = this.#nextId++;
+        this.pies.set(pieId, { settings: body, cash: 0 });
+        return this.#pie(pieId);
+      }
+      case "updatePie": {
+        const pie = this.pies.get(pathId ?? 0);
+        if (!pie) return apiError(404, "entity-not-found", NOT_FOUND, "Pie not found");
+        pie.settings = { ...pie.settings, ...body };
+        return this.#pie(pathId ?? 0);
+      }
+      case "deletePie":
+        return this.pies.delete(pathId ?? 0) ? { status: 200 } : apiError(404, "entity-not-found", NOT_FOUND, "Pie not found");
+      case "duplicatePie": {
+        const pie = this.pies.get(pathId ?? 0);
+        if (!pie) return apiError(404, "entity-not-found", NOT_FOUND, "Pie not found");
+        const pieId = this.#nextId++;
+        this.pies.set(pieId, { settings: { ...pie.settings, ...body }, cash: 0 });
+        return this.#pie(pieId);
+      }
+    }
+  }
+  #pieSummary(id, cash) {
+    return { id, cash, progress: 0, status: "ON_TRACK", dividendDetails: { gained: 0, inCash: 0, reinvested: 0 } };
+  }
+  #pie(id) {
+    const pie = this.pies.get(id);
+    if (!pie) return apiError(404, "entity-not-found", NOT_FOUND, "Pie not found");
+    const details = {
+      settings: { ...pie.settings, id, creationDate: (/* @__PURE__ */ new Date(0)).toISOString() },
+      instruments: Object.entries(pie.settings.instrumentShares ?? {}).map(([ticker, share]) => ({
+        ticker,
+        expectedShare: share,
+        currentShare: 0,
+        ownedQuantity: 0
+      }))
+    };
+    return { body: details };
+  }
+  #cancel(orderId) {
+    const pending = this.pending.get(orderId);
+    if (!pending) return apiError(404, "entity-not-found", NOT_FOUND, "Order not found");
+    this.pending.delete(orderId);
+    this.cash += pending.reservedCash;
+    this.orderHistory.unshift({ order: { ...pending.order, status: "CANCELLED" } });
+    return { status: 200 };
+  }
+  #place(id, body) {
+    const ticker = typeof body.ticker === "string" ? body.ticker : "";
+    const quantity = typeof body.quantity === "number" ? body.quantity : Number.NaN;
+    if (!this.#instrument(ticker)) return apiError(400, "instrument-not-found", REFUSED, `No instrument ${ticker}`);
+    if (!Number.isFinite(quantity) || quantity === 0)
+      return apiError(400, "invalid-request", INVALID, "Invalid payload");
+    if (decimalPlaces(quantity) > 4)
+      return apiError(400, "quantity-precision-mismatch", REFUSED, "invalid quantity precision 4");
+    if (id !== "placeMarketOrder" && "extendedHours" in body)
+      return apiError(400, "invalid-request", INVALID, "Invalid payload");
+    if (!this.marketOpen) return apiError(400, "market-closed", REFUSED, "The market is closed");
+    const type = {
+      placeMarketOrder: "MARKET",
+      placeLimitOrder: "LIMIT",
+      placeStopOrder: "STOP",
+      placeStopLimitOrder: "STOP_LIMIT"
+    }[id] ?? "MARKET";
+    const limitPrice = typeof body.limitPrice === "number" ? body.limitPrice : void 0;
+    const stopPrice = typeof body.stopPrice === "number" ? body.stopPrice : void 0;
+    const price = limitPrice ?? stopPrice ?? this.priceOf(ticker);
+    const buying = quantity > 0;
+    const holding = this.holdings.get(ticker);
+    const available = holding ? holding.quantity - holding.inPies - this.#reservedShares(ticker) : 0;
+    if (buying && roundMoney(quantity * price) > roundMoney(this.cash)) {
+      return apiError(400, "insufficient-free-for-stocks-buy", REFUSED, "Insufficient funds");
+    }
+    if (!buying && -quantity > roundShares(available) + 1e-9)
+      return apiError(
+        400,
+        "selling-equity-not-owned",
+        REFUSED,
+        `Selling more equities than owned, owned: ${String(roundShares(available))}`
+      );
+    const order = {
+      id: this.#nextId++,
+      ticker,
+      instrument: this.#instrumentSummary(ticker),
+      type,
+      side: buying ? "BUY" : "SELL",
+      status: "NEW",
+      strategy: "QUANTITY",
+      quantity: Math.abs(quantity),
+      filledQuantity: 0,
+      currency: this.#instrument(ticker)?.currencyCode ?? this.currency,
+      initiatedFrom: "API",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      extendedHours: body.extendedHours === true,
+      ...limitPrice !== void 0 && { limitPrice },
+      ...stopPrice !== void 0 && { stopPrice },
+      ...typeof body.timeValidity === "string" && { timeInForce: body.timeValidity }
+    };
+    if (type === "MARKET") {
+      this.#execute(order, price);
+      return { body: order };
+    }
+    const reservedCash = buying ? roundMoney(quantity * price) : 0;
+    this.cash -= reservedCash;
+    this.pending.set(order.id ?? 0, { order, reservedCash, reservedShares: buying ? 0 : -quantity });
+    return { body: order };
+  }
+  #execute(order, price) {
+    const ticker = order.ticker ?? "";
+    const quantity = order.quantity ?? 0;
+    const buying = order.side === "BUY";
+    const value = roundMoney(quantity * price);
+    const holding = this.holdings.get(ticker);
+    let realised = 0;
+    if (buying) {
+      this.cash = roundMoney(this.cash - value);
+      if (holding) {
+        const total = holding.quantity + quantity;
+        holding.averagePrice = (holding.averagePrice * holding.quantity + price * quantity) / total;
+        holding.quantity = roundShares(total);
+      } else {
+        this.holdings.set(ticker, {
+          ticker,
+          quantity,
+          averagePrice: price,
+          inPies: 0,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    } else if (holding) {
+      realised = roundMoney((price - holding.averagePrice) * quantity);
+      this.cash = roundMoney(this.cash + value);
+      holding.quantity = roundShares(holding.quantity - quantity);
+      if (holding.quantity <= 0) this.holdings.delete(ticker);
+    }
+    this.realisedProfitLoss += realised;
+    const filled = { ...order, status: "FILLED", filledQuantity: quantity, filledValue: value };
+    this.orderHistory.unshift({
+      order: filled,
+      fill: {
+        id: this.#nextId++,
+        price,
+        quantity,
+        filledAt: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "TRADE",
+        tradingMethod: "TOTV",
+        walletImpact: {
+          currency: this.currency,
+          fxRate: 1,
+          netValue: buying ? -value : value,
+          realisedProfitLoss: realised,
+          taxes: []
+        }
+      }
+    });
+    return filled;
+  }
+  #page(request, all, tickerOf, withTime = false) {
+    const limit = request.query.limit === void 0 ? 20 : Number(request.query.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 50)
+      return apiError(
+        400,
+        "invalid-request",
+        INVALID,
+        limit > 50 ? "Limit cannot be greater than 50" : "Invalid limit"
+      );
+    const ticker = request.query.ticker;
+    const items = ticker ? all.filter((item) => tickerOf(item) === ticker) : all;
+    const start = request.query.cursor === void 0 ? 0 : Number(request.query.cursor);
+    const slice = items.slice(start, start + limit);
+    const end = start + limit;
+    let nextPagePath = null;
+    if (end < items.length) {
+      const query = new URLSearchParams({ limit: String(limit), cursor: String(end) });
+      if (ticker) query.set("ticker", ticker);
+      if (withTime) query.set("time", (/* @__PURE__ */ new Date(0)).toISOString());
+      nextPagePath = `${request.path}?${query.toString()}`;
+    }
+    return { body: { items: slice, nextPagePath } };
+  }
+  #exportsRefused() {
+    return this.environment === "demo" && !this.exportsOnDemo ? apiError(403, "not-available-in-demo-account", "The action is not allowed in demo account") : void 0;
+  }
+  #requestReport(body) {
+    const refused = this.#exportsRefused();
+    if (refused) return refused;
+    const reportId = this.#nextId++;
+    this.reports.push({
+      reportId,
+      status: "Queued",
+      timeFrom: typeof body.timeFrom === "string" ? body.timeFrom : null,
+      timeTo: typeof body.timeTo === "string" ? body.timeTo : null,
+      dataIncluded: body.dataIncluded ?? null
+    });
+    return { body: { reportId } };
+  }
+  #listReports() {
+    const refused = this.#exportsRefused();
+    if (refused) return refused;
+    const listed = this.reports.map((report) => ({ ...report }));
+    for (const report of this.reports) {
+      if (report.status === "Queued") report.status = "Finished";
+      if (report.status === "Finished")
+        report.downloadLink = `${REPORT_HOST}/${report.reportId ?? 0}.csv?signature=fake`;
+    }
+    return { body: listed };
+  }
+  #download(request) {
+    if (request.authorized) {
+      return toResponse({ status: 400, body: "The fake refuses report downloads that carry API credentials." });
+    }
+    const id = Number(request.path.replace(/\D/g, ""));
+    if (!this.reports.some((report) => report.reportId === id && report.status === "Finished"))
+      return toResponse({ status: 404, body: "No such report" });
+    const header = "Action,Time,ISIN,Ticker,Name,No. of shares,Price / share,Currency (Price / share),Total,Currency (Total)";
+    const rows = this.orderHistory.map(
+      ({ order, fill }) => [
+        order?.side === "SELL" ? "Market sell" : "Market buy",
+        fill?.filledAt ?? "",
+        order?.instrument?.isin ?? "",
+        order?.ticker ?? "",
+        `"${order?.instrument?.name ?? ""}"`,
+        fill?.quantity ?? "",
+        fill?.price ?? "",
+        order?.currency ?? "",
+        Math.abs(fill?.walletImpact?.netValue ?? 0),
+        this.currency
+      ].join(",")
+    );
+    return toResponse({ body: `${[header, ...rows].join("\n")}
+`, headers: { "content-type": "text/csv" } });
+  }
+};
+
+// src/testing/index.ts
+function createFakeTrading212(options = {}) {
+  const environment = options.environment ?? "demo";
+  const server = new FakeTrading212Server(options.state, environment);
+  const client = new Trading212({
+    rateLimit: "off",
+    trading: "enabled",
+    ...options.client,
+    environment,
+    apiKey: FAKE_API_KEY,
+    apiSecret: FAKE_API_SECRET,
+    fetch: server.fetch
+  });
+  return { client, server };
+}
+
+export { DEFAULT_INSTRUMENTS, FAKE_API_KEY, FAKE_API_SECRET, FakeTrading212Server, createFakeTrading212, networkError, scriptedFetch, weekOfSessions };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kkkermit/trading212.js",
-	"version": "0.1.0",
+	"version": "0.1.1",
 	"description": "Unofficial, zero-dependency TypeScript client for the Trading 212 Public API: typed, rate-limit aware, safe around live money, with errors that tell you how to fix them.",
 	"keywords": [
 		"trading212",
@@ -67,7 +67,7 @@
 		"./package.json": "./package.json"
 	},
 	"bin": {
-		"trading212": "./dist/cli.js"
+		"trading212": "dist/cli.js"
 	},
 	"files": [
 		"dist",
@@ -98,7 +98,7 @@
 		"fixtures:capture": "tsx scripts/captureErrors.ts",
 		"secrets": "secretlint \"**/*\"",
 		"changeset": "changeset",
-		"release": "npm run check && changeset publish",
+		"prepack": "npm run build",
 		"prepare": "husky",
 		"smoke": "node scripts/smoke.mjs && node scripts/smoke.cjs",
 		"example": "tsx --tsconfig examples/tsconfig.json",