@hyperbridge/simplex 0.17.0 → 0.18.0

package/dist/types-BPyUX8qu.d.cts

@@ -1,663 +0,0 @@
-import pino from 'pino';
-
-declare const LOG_LEVELS: readonly ["trace", "debug", "info", "warn", "error"];
-type LogLevel = (typeof LOG_LEVELS)[number];
-/**
- * Anything that accepts a line of text: `process.stdout`, a `fs` write stream, a
- * socket, a `pino-pretty` transform, or an object literal that forwards into
- * your own logger. Node's `Writable` satisfies it as-is.
- */
-interface LogSink {
-    write(line: string): void;
-}
-type LogFn = {
-    (obj: unknown, msg?: string, ...args: unknown[]): void;
-    (msg: string, ...args: unknown[]): void;
-};
-interface Logger {
-    trace: LogFn;
-    debug: LogFn;
-    info: LogFn;
-    warn: LogFn;
-    error: LogFn;
-    fatal: LogFn;
-}
-type LoggerOptions = {
-    module?: string;
-};
-/**
- * An isolated logging destination: its own sinks, its own level, its own pino
- * instance.
- *
- * Each `Simplex` owns one, so two fillers in a process log to their own sinks at
- * their own verbosity and never cross-contaminate. Services receive the context
- * their filler was started with and resolve module loggers from it.
- */
-declare class LoggerContext {
-    private level;
-    private readonly sinks;
-    private base;
-    private readonly children;
-    constructor(options?: {
-        level?: LogLevel;
-        sink?: LogSink;
-    });
-    /**
-     * Drops the memoized loggers so the next call rebuilds at the current level
-     * and sink set. Module loggers are wrappers rather than pino instances
-     * precisely so this reaches loggers that already exist — replacing the base
-     * logger would leave every service that had captured a child logging at the
-     * old level forever.
-     */
-    private invalidate;
-    private baseLogger;
-    private childFor;
-    /** Registers a destination and returns a function that removes it. */
-    addSink(sink: LogSink): () => void;
-    /** Sets verbosity, including for loggers already handed out. */
-    setLevel(level: LogLevel): void;
-    /** A logger tagged with `module`. Safe to hold; it resolves the current state per call. */
-    get(module?: string): Logger;
-    /** @internal — used by {@link ModuleLogger} to resolve per call. */
-    resolve(module?: string): pino.Logger;
-}
-/**
- * Registers a destination on the process-wide context and returns a function
- * that removes it.
- *
- * This is for the application layer. To capture a specific filler's output, pass
- * `SimplexOptions.logger` instead — a filler's records go to its own context,
- * not here.
- */
-declare function addLogSink(sink: LogSink): () => void;
-/** Sets the level of the process-wide context. Does not affect running fillers. */
-declare function configureLogger(level: LogLevel): void;
-/** A logger on the process-wide context. Instance-scoped code resolves from its own {@link LoggerContext}. */
-declare function getLogger(moduleOrOptions?: string | LoggerOptions): Logger;
-
-/**
- * The persistence contract for a running filler.
- *
- * Everything simplex must remember across a restart lives behind these four
- * stores: submitted bids (so deposits can be reclaimed), the order-activity
- * feed, the operator's limit orders, and a scrap of operator state. Nothing
- * else in the filler touches a database, a file, or a data directory.
- *
- * Every method is async. The bundled SQLite adapter is synchronous underneath
- * and simply returns resolved promises — the async signature exists so a
- * consumer can back these with Postgres, Redis, or a hosted API. Making the
- * interface synchronous would have limited "bring your own backend" to backends
- * that are local and synchronous, which is nearly the same as not having the
- * interface at all.
- */
-interface SimplexDataStore {
-    bids: BidStore;
-    activity: ActivityStore;
-    state: StateStore;
-    limitOrders: LimitOrderStore;
-    inventory: InventoryStore;
-    /** Releases any underlying handles. Called by `Simplex.stop()`. */
-    close?(): Promise<void>;
-}
-/** A bid submitted to Hyperbridge's solver-selection pallet. */
-interface StoredBid {
-    id: number;
-    commitment: string;
-    /** The identifier Hyperbridge files the bid under; see {@link BidInsert.bid}. */
-    bid: string | null;
-    extrinsicHash: string | null;
-    blockHash: string | null;
-    success: boolean;
-    /**
-     * The submission timed out with the extrinsic still in Hyperbridge's pool. It
-     * may yet land and reserve a deposit, so the sweep treats it as reclaimable
-     * even though `success` is false.
-     */
-    pending: boolean;
-    error: string | null;
-    /** SQLite-style "YYYY-MM-DD HH:MM:SS" in UTC. Sorts lexicographically. */
-    createdAt: string;
-    retracted: boolean;
-    retractedAt: string | null;
-    retractExtrinsicHash: string | null;
-    /** The order was seen filled on-chain, so this bid can never win — reclaim its deposit now. */
-    dead: boolean;
-    /**
-     * What this bid holds against the operator's limit orders, at 1e18, in the
-     * order the payout draws on them. Empty for a bid placed before limit orders
-     * priced anything, and empty again once the hold has been settled, whether it
-     * was released because the bid lost or converted because the bid filled.
-     *
-     * More than one when a swap drew on several levels: the orderbook quotes a
-     * same-chain swapper across every level that can fill the trade together, so a
-     * bid may be meeting several of the operator's own orders at once.
-     */
-    reservations: LimitOrderHold[];
-}
-/** One limit order and what a bid holds against it, at 1e18. */
-interface LimitOrderHold {
-    limitOrderId: string;
-    amount: string;
-    /**
-     * The take the bid signed beside `amount`, in the input token's raw units. With it, settlement
-     * works out what the gateway charged: the escrow it released at `amount / take`. Holds recorded
-     * before bids carried their own rate have none.
-     */
-    take?: string;
-    /**
-     * The input token's decimals on the order's source chain, which is where `take` and the escrow
-     * a fill releases are counted. With it, settlement records what a fill took in at 1e18. Holds
-     * recorded before fills kept their input have none.
-     */
-    takeDecimals?: number;
-}
-interface BidInsert {
-    commitment: string;
-    /**
-     * The identifier Hyperbridge files the bid under, `keccak256` of its calldata. Bids on one
-     * incoming order share a commitment, and this is what tells them apart. It is also what
-     * retracting the bid names, so it is recorded here at placement rather than looked up later:
-     * a bid still in Hyperbridge's pool is not in its storage yet, but its retraction, sent after it
-     * from the same account, lands after it and reclaims its deposit all the same.
-     */
-    bid?: string;
-    /** What this bid holds against the limit orders that priced it, best first. */
-    reservations?: LimitOrderHold[];
-    extrinsicHash?: string;
-    blockHash?: string;
-    success: boolean;
-    /** Submission is still in the pool; see {@link StoredBid.pending}. */
-    pending?: boolean;
-    error?: string;
-}
-interface BidStats {
-    total: number;
-    successful: number;
-    failed: number;
-    retracted: number;
-    /** Deposits still locked: successful or pending, and not yet retracted. */
-    pendingRetraction: number;
-}
-/**
- * Persistent record of every bid submitted to Hyperbridge.
- *
- * This is the money-critical store: a successful bid locks a deposit that is
- * only reclaimable by retracting it, and the retraction sweep finds what to
- * reclaim by querying here. An implementation that loses writes leaks deposits,
- * so `store` must be durable before it resolves — do not buffer it in memory
- * and flush later.
- */
-interface BidStore {
-    store(bid: BidInsert): Promise<void>;
-    /** The most recent bid for a commitment, or null. */
-    byCommitment(commitment: string): Promise<StoredBid | null>;
-    /** Every bid for any of `commitments`, newest first. Empty input resolves empty. */
-    byCommitments(commitments: string[]): Promise<StoredBid[]>;
-    /** Unretracted bids whose deposit may still be locked: confirmed or pooled. */
-    unretractedReclaimable(): Promise<StoredBid[]>;
-    /**
-     * Bids due for retraction: successful *or still pending*, unretracted, and
-     * either older than `maxAgeMs` or flagged dead. Pending counts because a
-     * pooled extrinsic that later lands reserves a deposit exactly like a
-     * confirmed one. Dead bids ignore the age cut — their deposit is
-     * reclaimable immediately, so a failed attempt retries on the next sweep
-     * rather than waiting out the TTL.
-     */
-    expiredUnretracted(maxAgeMs: number): Promise<StoredBid[]>;
-    /**
-     * Marks a bid retracted. Also called when the chain reports `BidNotFound`:
-     * bids only leave the pallet by retraction, so "no bid" means there is
-     * nothing left to reclaim and no hash is available.
-     *
-     * Resolves false when no unretracted bid matched (already retracted, or never
-     * stored) — the caller treats that as success, not an error.
-     */
-    markRetracted(commitment: string, retractExtrinsicHash: string | null): Promise<boolean>;
-    /** Flags a bid dead (its order was filled on-chain). False when nothing matched. */
-    markDead(commitment: string): Promise<boolean>;
-    /**
-     * Takes what this bid holds, exactly once, and returns it.
-     *
-     * A losing bid gives its holds back and a winning one converts them into
-     * draw-downs, and both routes end at the same bid row — a bid that won is still
-     * retracted eventually, by the stale sweep, so an unguarded release would undo
-     * a conversion that already happened. Whichever settles first claims them here;
-     * the other gets an empty list and does nothing.
-     */
-    /**
-     * Takes the holds off a bid, exactly once, and hands them to the caller.
-     *
-     * With a `bid` it claims that one bid; without, every outstanding hold on the
-     * commitment, which is what a filled or dead order needs so no bid's hold is
-     * left behind.
-     */
-    claimReservation(commitment: string, bid?: string): Promise<LimitOrderHold[]>;
-    /**
-     * Every bid that drew on a limit order, newest first. What makes a `remaining`
-     * explicable to the operator: which bids took the difference.
-     */
-    byLimitOrder(limitOrderId: string, limit?: number): Promise<StoredBid[]>;
-    /** Newest first. Implementations should cap `limit` at a few hundred. */
-    recent(limit?: number): Promise<StoredBid[]>;
-    /** Failed bids, newest first — for debugging. */
-    failed(limit?: number): Promise<StoredBid[]>;
-    byDateRange(from: Date, to: Date): Promise<StoredBid[]>;
-    stats(): Promise<BidStats>;
-}
-/**
- * `bid`: this filler's bid for the order was accepted by Hyperbridge (txHash is
- * the extrinsic hash). `filled`: this filler filled the order on chain. `lost`:
- * another filler did (reason carries its address). `executed`: a direct fill
- * attempt or a failed bid.
- */
-type ActivityType = "detected" | "bid" | "filled" | "lost" | "executed" | "skipped" | "rebalance";
-/** One leg of an order as the activity feed records it. */
-interface OrderLeg {
-    /** 20-byte token address; the zero address is the chain's native asset. */
-    token: string;
-    /** Raw on-chain amount as a decimal string (bigint-safe). */
-    amount: string;
-    /** Registry symbol when the token is known to this filler, else null. */
-    symbol: string | null;
-    /** ERC-20 decimals when they could be read, else null (the UI then shows the raw amount). */
-    decimals: number | null;
-}
-/**
- * What the activity feed knows about an order, captured when it was detected
- * and attached to every later event for that order so each row stands alone.
- */
-interface OrderSummary {
-    user: string;
-    /** Source chain state machine id, e.g. "EVM-8453". */
-    source: string;
-    destination: string;
-    /** Hash of the transaction that placed the order on the source chain. */
-    placedTxHash: string | null;
-    /** 20-byte referrer from the order's graffiti tag; null when unattributed. */
-    referrer: string | null;
-    inputs: OrderLeg[];
-    outputs: OrderLeg[];
-    /** Order deadline (block number) as a decimal string. */
-    deadline: string;
-}
-interface ActivityEvent {
-    id: number;
-    ts: number;
-    type: ActivityType;
-    orderId: string | null;
-    chainId: number | null;
-    strategy: string | null;
-    success: boolean | null;
-    /** Skip reason or execution error. */
-    reason: string | null;
-    volumeUsd: number | null;
-    profitUsd: number | null;
-    txHash: string | null;
-    /** The order this event concerns, when known; null for rebalances and legacy rows. */
-    order: OrderSummary | null;
-}
-type ActivityInsert = Partial<Omit<ActivityEvent, "id" | "ts" | "type">> & {
-    type: ActivityType;
-};
-type WalletTxKind = "send" | "sweep" | "redeem";
-/** One outbound transaction from the filler wallet (operator send, vault sweep/redeem). */
-interface WalletTx {
-    id: number;
-    ts: number;
-    kind: WalletTxKind;
-    chainId: number | null;
-    /** What left the wallet: symbol and decimal amount (sends, sweeps, redeems). */
-    token: string | null;
-    amount: string | null;
-    to: string | null;
-    txHash: string;
-    sponsored: boolean | null;
-    /** What came back: vault shares for a sweep, the underlying for a redeem. */
-    tokenIn?: string | null;
-    amountIn?: string | null;
-}
-/**
- * Append-only feed of what the filler did, backing the operator dashboard.
- *
- * Unlike {@link BidStore} this is observability, not correctness: dropping a
- * row costs a line in the activity view and nothing else, so an implementation
- * may prune, sample, or cap history freely.
- */
-interface ActivityStore {
-    /** Appends an event and resolves the stored row (its `id` and `ts` assigned). */
-    record(event: ActivityInsert): Promise<ActivityEvent>;
-    /** Newest first; pass `beforeId` to page backwards. */
-    recent(limit?: number, beforeId?: number): Promise<ActivityEvent[]>;
-    /** Fill events carrying both a tx hash and a chain, newest first. */
-    fills(limit?: number): Promise<ActivityEvent[]>;
-    recordWalletTx(tx: Omit<WalletTx, "id" | "ts">): Promise<void>;
-    walletTxs(limit?: number): Promise<WalletTx[]>;
-    /** Sweep and redeem rows recorded without amounts (before the ledger carried them). Newest first. */
-    walletTxsWithoutAmounts(limit?: number): Promise<WalletTx[]>;
-    /** Fills in the amount fields of one ledger row. */
-    updateWalletTx(id: number, patch: Pick<WalletTx, "token" | "amount" | "to" | "tokenIn" | "amountIn">): Promise<void>;
-    /**
-     * Distinct order ids among the newest rows that carry no order summary —
-     * rows written before summaries existed. Newest first, at most `limit`.
-     */
-    orderIdsMissingSummary(limit?: number): Promise<string[]>;
-    /** Sets the summary on every row for `orderId` that lacks one; resolves the rows it changed. */
-    attachOrder(orderId: string, order: OrderSummary): Promise<ActivityEvent[]>;
-    /**
-     * Orders (rows sharing an order id) newest-activity first, one page at a
-     * time. `page` is 1-based; `total` counts every distinct order.
-     */
-    orderHistory(page: number, pageSize: number): Promise<OrderHistoryPage>;
-    /** Whether any row exists for `orderId` — i.e. this filler has seen the order. */
-    knowsOrder(orderId: string): Promise<boolean>;
-    /**
-     * Orders this filler bid on that have no on-chain outcome recorded yet: a
-     * `bid` row, or a legacy bid-time `filled` row (those carry `volumeUsd`), and
-     * neither a `lost` row nor an observed `filled` row (no `volumeUsd`). Newest first.
-     */
-    unsettledOrders(limit?: number): Promise<string[]>;
-    /** Retypes an order's legacy bid-time `filled` rows to `bid`; resolves the rows it changed. */
-    retypeLegacyBid(orderId: string): Promise<ActivityEvent[]>;
-}
-/** One order's rows, newest first. */
-interface OrderHistoryEntry {
-    orderId: string;
-    events: ActivityEvent[];
-}
-interface OrderHistoryPage {
-    page: number;
-    pageSize: number;
-    total: number;
-    orders: OrderHistoryEntry[];
-}
-/** Which way round a limit order trades its book's pair. */
-type LimitOrderSide = "BID" | "ASK";
-/**
- * `open`: live, and bids may draw on it. `resizing`: a repost is in flight after
- * a fill, so the orderbook entry may be missing until it lands. `filled`: worked
- * down past the dust floor. `cancelled`: withdrawn by the operator. `expired`:
- * past the operator's own `expiresAt` and swept off the book. `rejected`: the
- * orderbook refused it and `lastError` says why.
- */
-type LimitOrderStatus = "open" | "resizing" | "filled" | "cancelled" | "expired" | "rejected";
-/**
- * One of the operator's limit orders.
- *
- * This record is what simplex prices against and draws down; the orderbook entry
- * is a derived copy that expires and is reposted. Amounts and prices are decimal
- * strings at 1e18, the unit the orderbook takes and returns, whatever decimals
- * the tokens use on their own chains.
- */
-interface LimitOrder {
-    /** Stable across every repost, unlike `commitment`. */
-    id: string;
-    /** Orderbook book id, with the symbols it resolved to. */
-    book: string;
-    base: string;
-    quote: string;
-    side: LimitOrderSide;
-    /** Where simplex fills, as a state machine id. */
-    fillChain: string;
-    /** Quote per 1 base: the rate simplex signs, before the orderbook's fee haircut. */
-    price: string;
-    /** The output simplex offered to pay when the order was created. */
-    size: string;
-    /** Output not yet delivered. */
-    remaining: string;
-    /** Output promised to bids that have neither filled nor been retracted. */
-    reserved: string;
-    /** Source chains this order accepts swaps from. Never empty. */
-    acceptedSources: string[];
-    /** TTL written into each posting. */
-    ttlSecs: number;
-    /** Operator expiry for the limit order itself, independent of the posting's. */
-    expiresAt: string | null;
-    status: LimitOrderStatus;
-    /** The current posting's commitment, absent while nothing is live. */
-    commitment: string | null;
-    /** Bumped on every repost, so each posting hashes differently. */
-    orderNonce: string;
-    /**
-     * The EntryPoint the current posting's op was signed for. Null while nothing is
-     * posted, and on a posting stored before this was recorded, which was signed
-     * for v0.8.
-     */
-    entryPoint: string | null;
-    /** When the current posting expires, as the orderbook reported it. */
-    bookExpiresAt: string | null;
-    /** `Order.price` from the orderbook, which shades `price` by the protocol fee. */
-    bookPrice: string | null;
-    /** The last rejection, as "CODE: message". */
-    lastError: string | null;
-    /** SQLite-style "YYYY-MM-DD HH:MM:SS" in UTC. Sorts lexicographically. */
-    createdAt: string;
-    updatedAt: string;
-}
-/** What the operator supplies; everything else is derived or defaulted. */
-interface LimitOrderInsert {
-    id: string;
-    book: string;
-    base: string;
-    quote: string;
-    side: LimitOrderSide;
-    fillChain: string;
-    price: string;
-    size: string;
-    acceptedSources: string[];
-    ttlSecs: number;
-    expiresAt?: string | null;
-    /** Where the order's posted-op nonce starts. Defaults to "0". */
-    orderNonce?: string;
-}
-interface LimitOrderFilter {
-    status?: LimitOrderStatus;
-    fillChain?: string;
-    book?: string;
-}
-/** The fields a posting writes back, applied together so a half-posted row is never visible. */
-interface LimitOrderPosting {
-    commitment: string | null;
-    bookExpiresAt: string | null;
-    bookPrice: string | null;
-    orderNonce: string;
-    entryPoint: string | null;
-    status: LimitOrderStatus;
-    lastError: string | null;
-}
-/**
- * Persistent record of the operator's limit orders.
- *
- * This is inventory, not a cache: `remaining` and `reserved` are what stop two
- * chains from paying out the same liability twice, so a store that loses writes
- * overcommits real money.
- */
-/**
- * One fill that drew a limit order down: kept apart from the bid that priced it, whose
- * holds are cleared on settlement, so an order keeps its history across every resize.
- */
-interface LimitOrderFill {
-    id: number;
-    limitOrderId: string;
-    /** The swap order the fill settled. */
-    commitment: string;
-    /** The identifier Hyperbridge filed the executed bid under, when known. */
-    bid: string | null;
-    /** What the fill drew the limit order down by, at 1e18 in the token it pays. */
-    amount: string;
-    /**
-     * The escrow the fill released to the solver, at 1e18 in the token the order takes in. Null
-     * for a fill recorded before this was kept, and for one whose event carried no inputs.
-     */
-    amountIn: string | null;
-    /** The fill's transaction on the order's fill chain, when the event carried it. */
-    transactionHash: string | null;
-    /** SQLite-style "YYYY-MM-DD HH:MM:SS" in UTC. */
-    filledAt: string;
-}
-interface LimitOrderFillInsert {
-    limitOrderId: string;
-    commitment: string;
-    bid?: string | null;
-    amount: string;
-    amountIn?: string | null;
-    transactionHash?: string | null;
-}
-/**
- * A fill with the terms of the order it drew on: what profitability is worked out from. The
- * order's `price` stands in for the rate of a fill that kept no `amountIn`.
- */
-interface LimitOrderFillRecord {
-    id: number;
-    limitOrderId: string;
-    book: string;
-    base: string;
-    quote: string;
-    side: LimitOrderSide;
-    price: string;
-    amount: string;
-    amountIn: string | null;
-    filledAt: string;
-}
-interface LimitOrderStore {
-    create(order: LimitOrderInsert): Promise<LimitOrder>;
-    get(id: string): Promise<LimitOrder | null>;
-    list(filter?: LimitOrderFilter): Promise<LimitOrder[]>;
-    /** Every `open` order, which is what the matcher prices against. */
-    open(): Promise<LimitOrder[]>;
-    /**
-     * Records what the orderbook did with the current posting.
-     *
-     * `only` guards the write on the status the row still holds, and answers null
-     * when it has moved on. A posting is a slow round trip, and an operator's
-     * cancel or an expiry sweep that lands first must not be undone by an answer
-     * that was already in flight.
-     */
-    setPosting(id: string, posting: LimitOrderPosting, only?: readonly LimitOrderStatus[]): Promise<LimitOrder | null>;
-    setStatus(id: string, status: LimitOrderStatus, lastError?: string | null, only?: readonly LimitOrderStatus[]): Promise<LimitOrder | null>;
-    /**
-     * Adds `amount` to `reserved`, but only while the order is `open` and
-     * `remaining` covers this one hold. Resolves false when it does not.
-     *
-     * Other bids' holds do not count against it: a pending bid must not stop the
-     * next one going out, so the limit order bounds each bid and what fills draw
-     * down, not the sum of bids still waiting. The hold is bookkeeping, turned into
-     * a draw-down if the bid wins and given back if it loses. The write is still
-     * guarded on the `reserved` it read, so two holds landing together both count.
-     */
-    reserve(id: string, amount: string): Promise<boolean>;
-    /** Gives a reservation back, after a bid was retracted, lost or found dead. */
-    release(id: string, amount: string): Promise<void>;
-    /**
-     * Works the order down by output that has actually been delivered, floored at
-     * zero. Returns the order as it now stands, or null when there is none.
-     */
-    drawDown(id: string, amount: string): Promise<LimitOrder | null>;
-    /**
-     * Lowers an `open` order's `remaining` to `room + reserved`, where `room` is
-     * what the solver's account on chain will still pay for this order, at 1e18.
-     * Never raises it. Returns the order when it was lowered, null otherwise.
-     *
-     * `reserved` is added back because a fill the chain has already counted, but
-     * that has not been drawn down here yet, still holds its amount there until it
-     * settles. Clamping to `room` alone would take that fill off twice.
-     */
-    clampRemaining(id: string, room: string): Promise<LimitOrder | null>;
-    /** Records a fill against its limit order. Called alongside the draw-down it explains. */
-    recordFill(fill: LimitOrderFillInsert): Promise<void>;
-    /** Every fill of every limit order, oldest first, each with its order's terms. */
-    fillHistory(): Promise<LimitOrderFillRecord[]>;
-    /** A limit order's fills, newest first. */
-    fills(limitOrderId: string, limit?: number): Promise<LimitOrderFill[]>;
-    /**
-     * Runs `settle` as one unit where the backend can.
-     *
-     * A fill claims what its bid held, works the orders down by what went out and
-     * gives the rest back, and a crash between those leaves the hold released
-     * against an order that was never drawn down. The bid rows live in the same
-     * database as the limit orders, which is what lets one transaction cover both.
-     *
-     * Only store calls belong inside: they are synchronous underneath, so nothing
-     * else interleaves on the connection, which would not hold for a network call.
-     */
-    transaction<T>(settle: () => Promise<T>): Promise<T>;
-}
-/** Operator state that must survive a restart. */
-interface RuntimeState {
-    /** A pause set by the operator stays set across restarts. */
-    paused?: boolean;
-    /** Notification rules, browser subscriptions, and the per-installation VAPID identity. */
-    notifications?: NotificationRuntimeState;
-}
-interface NotificationSettings {
-    /** Alert once when aggregate spendable USD-stable liquidity crosses below this value. */
-    lowLiquidityThresholdUsd: number | null;
-    /** Alert after this filler completes a swap. */
-    swaps: boolean;
-}
-/** Transport-safe alert payload shared by Web Push and the native desktop shell. */
-interface OperatorNotification {
-    title: string;
-    body: string;
-    tag: string;
-    /** Relative dashboard destination to open when the operator clicks the alert. */
-    url: string;
-    /** Opaque, short-lived receipt used only to confirm native desktop test delivery. */
-    receiptId?: string;
-}
-interface StoredPushSubscription {
-    endpoint: string;
-    expirationTime?: number | null;
-    keys: {
-        p256dh: string;
-        auth: string;
-    };
-}
-interface NotificationRuntimeState {
-    settings: NotificationSettings;
-    vapid: {
-        publicKey: string;
-        privateKey: string;
-    };
-    subscriptions: StoredPushSubscription[];
-    /** Prevents restart/poll spam while liquidity remains below the configured threshold. */
-    lowLiquidityActive?: boolean;
-}
-interface StateStore {
-    get(): Promise<RuntimeState>;
-    /** Replaces the whole record. Keys absent from `state` are dropped. */
-    set(state: RuntimeState): Promise<void>;
-    /**
-     * Merges `patch` into the stored record atomically, leaving keys it does not
-     * name untouched. Optional: `patchRuntimeState` falls back to a read and a
-     * `set` for stores that cannot do better, which loses a key written
-     * concurrently. The bundled SQLite store implements it.
-     */
-    patch?(patch: Partial<RuntimeState>): Promise<RuntimeState>;
-}
-/**
- * What the solver held at one moment: whole tokens per symbol, counting the wallet and the
- * vaults on every chain.
- */
-interface InventorySnapshot {
-    id: number;
-    /** SQLite-style "YYYY-MM-DD HH:MM:SS" in UTC. */
-    takenAt: string;
-    balances: Record<string, number>;
-}
-/**
- * A record of what the solver held, taken about once a day.
- *
- * It is what profit is measured against: the inventory a period began with. The chain can say
- * what an account holds now but not what it held last week, so a snapshot that was never taken
- * cannot be recovered. Like {@link ActivityStore} it is observability rather than correctness:
- * a lost row costs a figure on the analytics page and nothing else.
- */
-interface InventoryStore {
-    record(balances: Record<string, number>): Promise<void>;
-    /** The most recent snapshot, or null when none has been taken. */
-    latest(): Promise<InventorySnapshot | null>;
-    /** Every snapshot taken at or after `from`, oldest first. */
-    since(from: Date): Promise<InventorySnapshot[]>;
-}
-
-export { type ActivityStore as A, type BidStore as B, getLogger as C, type OrderSummary as D, type InventoryStore as I, LoggerContext as L, type OrderHistoryPage as O, type RuntimeState as R, type SimplexDataStore as S, type WalletTx as W, type LogLevel as a, type Logger as b, type ActivityInsert as c, type ActivityEvent as d, type LimitOrderStore as e, type LimitOrder as f, type LimitOrderFilter as g, type LimitOrderFill as h, type StoredBid as i, type LogSink as j, type BidStats as k, type StateStore as l, type ActivityType as m, type BidInsert as n, type InventorySnapshot as o, type LimitOrderFillInsert as p, type LimitOrderFillRecord as q, type LimitOrderHold as r, type LimitOrderInsert as s, type LimitOrderPosting as t, type LimitOrderSide as u, type LimitOrderStatus as v, type OperatorNotification as w, type WalletTxKind as x, addLogSink as y, configureLogger as z };