@forgezero/runtime 0.1.14 → 0.1.15

package/dist/finance/rates.d.ts

@@ -1,178 +0,0 @@
-import { type Money } from './money';
-/**
- * What an asset is worth, and how old that answer is.
- *
- * The platform keeps its books in USD, so every balance in BTC, ETH or a token
- * has to be expressed in one unit before it can be added to anything. That
- * needs a rate, and a rate needs two things people routinely leave out:
- *
- *   A SOURCE  a peg is not a quote. USDT is 1 by definition and asking an
- *             exchange for it introduces an error where none existed — a
- *             stablecoin trading at 0.9994 would silently revalue every
- *             balance on the platform by six basis points.
- *   AN AGE    a rate with no timestamp is a rate that keeps quoting yesterday
- *             after the feed dies. Nothing here returns a value without also
- *             saying when it was true, and a caller pricing a withdrawal can
- *             refuse a stale one.
- *
- * ## Why the conversion itself is not implemented here
- *
- * `./money` already has `convert`, and the hard part is not
- * the multiplication — it is the decimal adjustment between assets of different
- * precision, which is where a factor-of-a-thousand error comes from. That is
- * written and tested once. This module answers *what rate*, never *how to
- * apply it*.
- */
-export declare class RateError extends Error {
-    readonly code: 'NO_RATE' | 'STALE_RATE' | 'BAD_RATE' | 'UNKNOWN_ASSET';
-    readonly asset?: string | undefined;
-    constructor(code: 'NO_RATE' | 'STALE_RATE' | 'BAD_RATE' | 'UNKNOWN_ASSET', message: string, asset?: string | undefined);
-}
-/** The unit the platform keeps its books in. */
-export declare const BASE_ASSET = "USD";
-export declare const RATE_SOURCES: readonly ["peg", "venue", "manual"];
-export type RateSource = (typeof RATE_SOURCES)[number];
-/**
- * How an asset is priced.
- *
- *   peg     fixed by definition and never fetched. USDT is 1.
- *   venue   quoted live from a chosen source, and therefore has an age.
- *   manual  an operator typed it. Also has an age, and deliberately so: a
- *           manual rate somebody set in March is more dangerous than a missing
- *           one, because it looks maintained.
- */
-export interface AssetRate {
-    asset: string;
-    source: RateSource;
-    /** USD per ONE whole unit, as a decimal string. Never a float. */
-    usd: string;
-    /** When this was true. Absent only for a peg, which has no such moment. */
-    atMs?: number;
-    /** For `venue`: which market it came from, so a wrong price is traceable. */
-    via?: string;
-}
-export interface AssetEntry {
-    code: string;
-    label: string;
-    decimals: number;
-    /**
-     * Chain this asset lives on, when it is a token.
-     *
-     * Absent for fiat and for a chain's own coin, which is why the field is
-     * optional rather than a string that sometimes says "native" — a sentinel
-     * value in a foreign key is a join nobody can write.
-     */
-    chain?: string;
-    /** Contract address for a token. Absent for a native coin. */
-    contract?: string;
-    enabled: boolean;
-    rate: AssetRate;
-}
-export declare function assertRate(rate: AssetRate): void;
-/** USDT and USDC at exactly 1, by definition rather than by quote. */
-export declare const peg: (asset: string, usd?: string) => AssetRate;
-export interface RateTableOptions {
-    /** How old a quoted rate may be before it is refused. Default 15 minutes. */
-    maxAgeMs?: number;
-    now?: () => number;
-}
-/**
- * The rates in force, and the one place that decides a quote is too old.
- *
- * Staleness is checked on READ rather than swept on a timer. A sweeper that
- * deletes old rates turns a stale-price incident into a missing-price incident
- * — the same outage with less information — and it can itself fail, leaving
- * rates that look fresh because nothing removed them.
- */
-export declare function createRateTable(options?: RateTableOptions): {
-    set(rate: AssetRate): void;
-    /** The raw entry, however old. For an admin screen that must show staleness. */
-    peek: (asset: string) => AssetRate | undefined;
-    ageOf(asset: string): number | undefined;
-    isStale(asset: string): boolean;
-    /**
-     * The rate, or a refusal that says which problem it is.
-     *
-     * Missing and stale are different failures with different fixes — one is
-     * an unconfigured asset, the other a dead feed — and collapsing them sends
-     * an operator to the wrong screen.
-     *
-     * Every valuation below goes through THIS, so the staleness rule exists in
-     * exactly one place. Two copies of it is two chances for a valuation path
-     * to accept a rate another path would refuse.
-     */
-    require(asset: string): AssetRate;
-    /**
-     * Value an amount in USD.
-     *
-     * Rounded DOWN. A rounding decision on a platform balance should leave the
-     * platform conservative about what it holds — a thousand rounded-up
-     * valuations become a shortfall nobody can locate.
-     */
-    toUsd(amount: Money): Money;
-    /** Sum a mixed bag of assets into one USD figure. */
-    totalUsd(amounts: readonly Money[]): Money;
-    all: () => AssetRate[];
-    clear: () => void;
-};
-export type RateTable = ReturnType<typeof createRateTable>;
-/**
- * Register an asset so `money` knows its precision.
- *
- * Called when an admin adds one. Getting `decimals` wrong is a factor-of-ten
- * error in every balance of that asset, which is why it is declared per asset
- * rather than defaulted — there is no safe default.
- */
-export declare function registerAsset(entry: AssetEntry): void;
-export declare const isRegistered: (code: string) => boolean;
-/**
- * A rate fetched from a venue.
- *
- * The fetcher is injected rather than imported, so this module stays free of a
- * transport and a test needs no network. The venue adapter already carries the
- * weight budget, which is the reason not to open a second HTTP path here.
- */
-export interface RateFetcher {
-    /** USD price of one whole unit, as a decimal string, or undefined if unquoted. */
-    quote(asset: string): Promise<string | undefined>;
-}
-export interface RefreshReport {
-    refreshed: string[];
-    /** Assets whose quote failed. The PREVIOUS rate is left in place — see below. */
-    failed: {
-        asset: string;
-        reason: string;
-    }[];
-    skipped: string[];
-}
-/**
- * Refresh every quoted asset.
- *
- * A failed quote leaves the old rate alone rather than clearing it. Clearing
- * would turn a brief feed outage into "no rate configured", which reads as a
- * misconfiguration and sends somebody to the wrong screen — and the old rate is
- * still visibly ageing, so `require()` refuses it on its own once it passes the
- * limit. Doing nothing is the correct action; doing nothing SILENTLY is not,
- * which is why failures are reported.
- */
-export declare function refreshRates(table: RateTable, fetcher: RateFetcher, args: {
-    assets: readonly AssetEntry[];
-    now?: () => number;
-}): Promise<RefreshReport>;
-/** The refresh as a job spec, for `@forgezero/runtime/jobs`. */
-export declare function rateRefreshJob(args: {
-    table: RateTable;
-    fetcher: RateFetcher;
-    assets: () => readonly AssetEntry[];
-    everyMs?: number;
-    key?: string;
-}): {
-    key: string;
-    everyMs: number;
-    run: () => Promise<{
-        ok: boolean;
-        detail: RefreshReport;
-    }>;
-};
-/** For an admin screen: what each asset is worth and how much to trust it. */
-export declare const describeRate: (rate: AssetRate, ageMs?: number) => string;

package/dist/finance/rates.js

@@ -1,292 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/finance/money.ts
-class MoneyError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "MoneyError";
-  }
-}
-var ASSETS = [
-  { code: "USDT", decimals: 6 },
-  { code: "USDC", decimals: 6 },
-  { code: "BTC", decimals: 8 },
-  { code: "ETH", decimals: 18 },
-  { code: "BNB", decimals: 18 },
-  { code: "EUR", decimals: 2 },
-  { code: "USD", decimals: 2 }
-];
-var REGISTRY = new Map(ASSETS.map((asset) => [asset.code, asset]));
-function defineAsset(spec) {
-  if (spec.decimals < 0 || spec.decimals > 30 || !Number.isInteger(spec.decimals)) {
-    throw new MoneyError("UNKNOWN_ASSET", `${spec.code}: decimals must be an integer 0–30.`);
-  }
-  REGISTRY.set(spec.code, spec);
-}
-function assetSpec(code) {
-  const spec = REGISTRY.get(code);
-  if (!spec)
-    throw new MoneyError("UNKNOWN_ASSET", `Unknown asset "${code}". Call defineAsset first.`);
-  return spec;
-}
-var money = (units, asset) => {
-  assetSpec(asset);
-  return { units, asset };
-};
-var zero = (asset) => money(0n, asset);
-function parseAmount(value, asset) {
-  const spec = assetSpec(asset);
-  const text = value.trim();
-  if (!/^-?\d+(\.\d+)?$/.test(text)) {
-    throw new MoneyError("NOT_FINITE", `"${value}" is not a plain decimal amount.`);
-  }
-  const negative = text.startsWith("-");
-  const [whole, fraction = ""] = text.replace("-", "").split(".");
-  if (fraction.length > spec.decimals) {
-    throw new MoneyError("PRECISION_LOSS", `${asset} has ${spec.decimals} decimals; "${value}" has ${fraction.length}.`);
-  }
-  const padded = fraction.padEnd(spec.decimals, "0");
-  const units = BigInt(whole + padded);
-  return { units: negative ? -units : units, asset };
-}
-function formatAmount(amount, options = {}) {
-  const spec = assetSpec(amount.asset);
-  const negative = amount.units < 0n;
-  const digits = (negative ? -amount.units : amount.units).toString().padStart(spec.decimals + 1, "0");
-  const whole = digits.slice(0, digits.length - spec.decimals);
-  let fraction = spec.decimals === 0 ? "" : digits.slice(digits.length - spec.decimals);
-  if (options.trim && fraction)
-    fraction = fraction.replace(/0+$/, "");
-  return `${negative ? "-" : ""}${whole}${fraction ? `.${fraction}` : ""}`;
-}
-function sameAsset(a, b) {
-  if (a.asset !== b.asset) {
-    throw new MoneyError("ASSET_MISMATCH", `Cannot combine ${a.asset} and ${b.asset}.`);
-  }
-}
-function add(a, b) {
-  sameAsset(a, b);
-  return { units: a.units + b.units, asset: a.asset };
-}
-function subtract(a, b) {
-  sameAsset(a, b);
-  return { units: a.units - b.units, asset: a.asset };
-}
-var negate = (amount) => ({ units: -amount.units, asset: amount.asset });
-var abs = (amount) => ({
-  units: amount.units < 0n ? -amount.units : amount.units,
-  asset: amount.asset
-});
-var isZero = (amount) => amount.units === 0n;
-var isNegative = (amount) => amount.units < 0n;
-function compare(a, b) {
-  sameAsset(a, b);
-  return a.units < b.units ? -1 : a.units > b.units ? 1 : 0;
-}
-var equals = (a, b) => a.asset === b.asset && a.units === b.units;
-var ROUNDING = ["down", "up", "half-up"];
-function divideRounded(numerator, denominator, mode) {
-  if (denominator === 0n)
-    throw new MoneyError("DIVIDE_BY_ZERO", "Division by zero.");
-  const negative = numerator < 0n !== denominator < 0n;
-  const a = numerator < 0n ? -numerator : numerator;
-  const b = denominator < 0n ? -denominator : denominator;
-  const quotient = a / b;
-  const remainder = a % b;
-  if (remainder === 0n)
-    return negative ? -quotient : quotient;
-  let result = quotient;
-  if (mode === "up")
-    result += 1n;
-  else if (mode === "half-up" && remainder * 2n >= b)
-    result += 1n;
-  return negative ? -result : result;
-}
-function mulRate(amount, rate, mode = "down") {
-  if (!/^-?\d+(\.\d+)?$/.test(rate.trim())) {
-    throw new MoneyError("NOT_FINITE", `"${rate}" is not a plain decimal rate.`);
-  }
-  const [whole, fraction = ""] = rate.trim().replace("-", "").split(".");
-  const scale = 10n ** BigInt(fraction.length);
-  const scaled = BigInt(whole + fraction) * (rate.trim().startsWith("-") ? -1n : 1n);
-  return { units: divideRounded(amount.units * scaled, scale, mode), asset: amount.asset };
-}
-function convert(amount, to, rate, mode = "down") {
-  const from = assetSpec(amount.asset);
-  const target = assetSpec(to);
-  const asTarget = mulRate({ units: amount.units, asset: to }, rate, mode);
-  const shift = target.decimals - from.decimals;
-  if (shift === 0)
-    return asTarget;
-  if (shift > 0)
-    return { units: asTarget.units * 10n ** BigInt(shift), asset: to };
-  return { units: divideRounded(asTarget.units, 10n ** BigInt(-shift), mode), asset: to };
-}
-function allocate(amount, parts) {
-  if (parts < 1)
-    throw new MoneyError("NOT_FINITE", "Cannot allocate into fewer than one part.");
-  const each = divideRounded(amount.units, BigInt(parts), "down");
-  const allocated = Array.from({ length: parts }, () => each);
-  let remainder = amount.units - each * BigInt(parts);
-  const step = remainder < 0n ? -1n : 1n;
-  for (let index = 0;remainder !== 0n; index = (index + 1) % parts) {
-    allocated[index] += step;
-    remainder -= step;
-  }
-  return allocated.map((units) => ({ units, asset: amount.asset }));
-}
-function toStep(amount, step, mode = "down") {
-  const stepUnits = parseAmount(step, amount.asset).units;
-  if (stepUnits <= 0n)
-    throw new MoneyError("NOT_FINITE", "A step must be positive.");
-  return { units: divideRounded(amount.units, stepUnits, mode) * stepUnits, asset: amount.asset };
-}
-var VERSION = "0.1.0";
-
-// src/finance/rates.ts
-class RateError extends Error {
-  code;
-  asset;
-  constructor(code, message, asset) {
-    super(message);
-    this.code = code;
-    this.asset = asset;
-    this.name = "RateError";
-  }
-}
-var BASE_ASSET = "USD";
-var RATE_SOURCES = ["peg", "venue", "manual"];
-var DECIMAL = /^\d+(\.\d+)?$/;
-function assertRate(rate) {
-  if (!DECIMAL.test(rate.usd.trim())) {
-    throw new RateError("BAD_RATE", `"${rate.usd}" is not a plain positive decimal.`, rate.asset);
-  }
-  if (Number(rate.usd) <= 0) {
-    throw new RateError("BAD_RATE", `A rate of ${rate.usd} for ${rate.asset} cannot be right.`, rate.asset);
-  }
-  if (rate.source === "peg" && rate.atMs !== undefined) {
-    throw new RateError("BAD_RATE", `${rate.asset} is pegged, so it has no timestamp — a peg that appears to age invites somebody to refresh it.`, rate.asset);
-  }
-  if (rate.source !== "peg" && rate.atMs === undefined) {
-    throw new RateError("BAD_RATE", `${rate.asset} is quoted from ${rate.source}, so it must carry when it was true. A rate with no age keeps quoting yesterday after the feed dies.`, rate.asset);
-  }
-}
-var peg = (asset, usd = "1") => ({ asset, source: "peg", usd });
-function createRateTable(options = {}) {
-  const maxAgeMs = options.maxAgeMs ?? 15 * 60000;
-  const now = options.now ?? Date.now;
-  const rates = new Map;
-  return {
-    set(rate) {
-      assertRate(rate);
-      rates.set(rate.asset, rate);
-    },
-    peek: (asset) => rates.get(asset),
-    ageOf(asset) {
-      const rate = rates.get(asset);
-      return rate?.atMs === undefined ? undefined : now() - rate.atMs;
-    },
-    isStale(asset) {
-      const rate = rates.get(asset);
-      if (!rate)
-        return true;
-      if (rate.source === "peg")
-        return false;
-      return now() - (rate.atMs ?? 0) > maxAgeMs;
-    },
-    require(asset) {
-      const rate = rates.get(asset);
-      if (!rate) {
-        throw new RateError("NO_RATE", `No USD rate is configured for ${asset}. Add a peg, a venue source, or a manual value.`, asset);
-      }
-      if (rate.source !== "peg" && now() - (rate.atMs ?? 0) > maxAgeMs) {
-        throw new RateError("STALE_RATE", `The ${asset} rate is ${Math.round((now() - (rate.atMs ?? 0)) / 60000)} minutes old; the limit is ${Math.round(maxAgeMs / 60000)}.`, asset);
-      }
-      return rate;
-    },
-    toUsd(amount) {
-      if (amount.asset === BASE_ASSET)
-        return amount;
-      return convert(amount, BASE_ASSET, this.require(amount.asset).usd, "down");
-    },
-    totalUsd(amounts) {
-      let total = parseAmount("0", BASE_ASSET);
-      for (const amount of amounts) {
-        const valued = this.toUsd(amount);
-        total = { units: total.units + valued.units, asset: BASE_ASSET };
-      }
-      return total;
-    },
-    all: () => [...rates.values()],
-    clear: () => rates.clear()
-  };
-}
-function registerAsset(entry) {
-  defineAsset({ code: entry.code, decimals: entry.decimals, label: entry.label });
-  assertRate(entry.rate);
-}
-var isRegistered = (code) => {
-  try {
-    assetSpec(code);
-    return true;
-  } catch {
-    return false;
-  }
-};
-async function refreshRates(table, fetcher, args) {
-  const now = args.now ?? Date.now;
-  const report = { refreshed: [], failed: [], skipped: [] };
-  for (const entry of args.assets) {
-    if (!entry.enabled || entry.rate.source !== "venue") {
-      report.skipped.push(entry.code);
-      continue;
-    }
-    try {
-      const usd = await fetcher.quote(entry.code);
-      if (!usd) {
-        report.failed.push({ asset: entry.code, reason: "the source does not quote it" });
-        continue;
-      }
-      table.set({ asset: entry.code, source: "venue", usd, atMs: now(), via: entry.rate.via });
-      report.refreshed.push(entry.code);
-    } catch (cause) {
-      report.failed.push({
-        asset: entry.code,
-        reason: cause instanceof Error ? cause.message : "unknown error"
-      });
-    }
-  }
-  return report;
-}
-function rateRefreshJob(args) {
-  return {
-    key: args.key ?? "rates.refresh",
-    everyMs: args.everyMs ?? 5 * 60000,
-    run: async () => {
-      const report = await refreshRates(args.table, args.fetcher, { assets: args.assets() });
-      return { ok: report.failed.length === 0, detail: report };
-    }
-  };
-}
-var describeRate = (rate, ageMs) => rate.source === "peg" ? `1 ${rate.asset} = ${formatAmount(parseAmount(rate.usd, BASE_ASSET), { trim: true })} USD, pegged` : `1 ${rate.asset} = ${rate.usd} USD from ${rate.via ?? rate.source}, ${ageMs === undefined ? "age unknown" : `${Math.round(ageMs / 1000)}s old`}`;
-export {
-  registerAsset,
-  refreshRates,
-  rateRefreshJob,
-  peg,
-  isRegistered,
-  describeRate,
-  createRateTable,
-  assertRate,
-  RateError,
-  RATE_SOURCES,
-  BASE_ASSET
-};

package/dist/finance/transfers.d.ts

@@ -1,153 +0,0 @@
-import { Refusal } from '@forgezero/access';
-import { type Money } from './money';
-/**
- * Deposits and withdrawals as ORDERED PIPELINES, not as functions.
- *
- * The seam exists before the thing that plugs into it, and that ordering is the
- * whole point. AML screening is deferred, but the position it will occupy —
- * first, before anything else looks at the transfer — is decided now. Adding a
- * first-position check to a function later means editing every path money
- * takes, and the one path somebody misses is the one that matters.
- *
- * So a transfer runs a list of stages. Adding screening later is registering a
- * stage. Nothing in deposit or withdrawal code changes.
- *
- * ## Stages refuse the way routes refuse
- *
- * A stage throws `Refusal` from `@forgezero/access`, which already carries a
- * status, a code, details and a retryable flag — and the HTTP pipeline already
- * knows how to turn one into a response. So a screening hit and a route denial
- * are the same shape, are logged the same way, and reach a client the same way.
- * Inventing a second failure type here would mean translating between them at
- * every boundary, and a translation layer is where a `retryable` flag gets lost.
- *
- * ## What this does NOT do
- *
- * No balance movement, no persistence, no ordering. Postings belong to
- * `./ledger` and ordering belongs to the queue keyed by account owner. This
- * decides only whether a transfer may proceed, and records why not.
- */
-export declare const DIRECTIONS: readonly ["deposit", "withdrawal"];
-export type Direction = (typeof DIRECTIONS)[number];
-export interface Transfer {
-    direction: Direction;
-    /** The account owner. Also the queue key the caller should be holding. */
-    owner: string;
-    amount: Money;
-    /** Chain, venue, or wherever this is coming from or going to. */
-    network?: string;
-    /** Destination for a withdrawal, source for a deposit. */
-    address?: string;
-    /** On-chain transaction hash, once one exists. */
-    txHash?: string;
-    /** Idempotency key. The queue's `dedupeKey` for this transfer. */
-    reference: string;
-    atMs: number;
-    /** Anything a stage wants to pass to a later one. */
-    context?: Record<string, unknown>;
-}
-/**
- * One check.
- *
- * Returning normally means "proceed". Throwing `Refusal` stops the transfer
- * with a reason a client can read. A stage may also return a patch, which is
- * merged into `context` for later stages — that is how screening passes a risk
- * score to an approval stage without either knowing about the other.
- */
-export interface Stage {
-    name: string;
-    /**
-     * Where this runs. Lower numbers first, ties broken by registration order.
-     *
-     * Explicit rather than array position, because the ordering IS the security
-     * property here and a list somebody reorders while tidying is a screening
-     * check that silently moved behind the balance check.
-     */
-    order: number;
-    directions?: readonly Direction[];
-    run(transfer: Transfer): Promise<void | Record<string, unknown>> | void | Record<string, unknown>;
-}
-/** Reserved for the check that must always be first. */
-export declare const SCREENING_ORDER = 0;
-export interface StageOutcome {
-    stage: string;
-    ok: boolean;
-    ms: number;
-    code?: string;
-}
-export interface PipelineResult {
-    ok: boolean;
-    transfer: Transfer;
-    stages: StageOutcome[];
-    /** The refusal that stopped it. Absent when it passed. */
-    refusal?: Refusal;
-}
-export declare class PipelineError extends Error {
-    readonly code: 'DUPLICATE_STAGE' | 'NO_SCREENING';
-    constructor(code: 'DUPLICATE_STAGE' | 'NO_SCREENING', message: string);
-}
-/**
- * Build a pipeline from stages.
- *
- * `requireScreening` is off by default and ON for production wiring: a platform
- * that has decided it needs AML should fail to start rather than run without
- * it. A missing screening stage is exactly the kind of omission that is
- * invisible until somebody audits, so it is expressible as a boot-time
- * assertion rather than a runbook item.
- */
-export declare function createTransferPipeline(options: {
-    stages: readonly Stage[];
-    requireScreening?: boolean;
-    now?: () => number;
-    /** Called for every stage, passed or refused. The audit hook. */
-    onStage?: (outcome: StageOutcome, transfer: Transfer) => void;
-}): {
-    stages: {
-        name: string;
-        order: number;
-    }[];
-    /**
-     * Run every stage that applies, in order, stopping at the first refusal.
-     *
-     * First refusal, not all of them: the stages are a sequence where each may
-     * depend on the last having passed, so continuing past one would run checks
-     * against a transfer that has already been rejected — and report failures
-     * that are consequences rather than causes.
-     */
-    run(transfer: Transfer): Promise<PipelineResult>;
-};
-export type TransferPipeline = ReturnType<typeof createTransferPipeline>;
-/**
- * The AML placeholder.
- *
- * Registered at order 0 and currently passes everything, which is what the
- * owner asked for. Its value is entirely in existing: the position is agreed,
- * the audit trail already records it running, and replacing the body later
- * changes no caller.
- *
- * `allow` is a parameter rather than a hard-coded `true` so a test can prove
- * the pipeline actually stops on a screening refusal — a stage that has never
- * refused anything is a stage nobody knows works.
- */
-export declare const screeningStage: (check?: (transfer: Transfer) => Promise<boolean> | boolean) => Stage;
-/** Amount bounds, per direction. */
-export declare const limitsStage: (limits: {
-    min?: Money;
-    max?: Money;
-    directions?: readonly Direction[];
-}) => Stage;
-/**
- * Enough available balance, for a withdrawal.
- *
- * Available, never total — a check against total lets a withdrawal spend what
- * an open order has already committed. Runs AFTER screening, deliberately: a
- * screened-out transfer should not reveal whether the balance was sufficient.
- */
-export declare const balanceStage: (available: (transfer: Transfer) => Promise<Money> | Money) => Stage;
-/** Hold a withdrawal for a human above a threshold. */
-export declare const approvalStage: (args: {
-    threshold: Money;
-    isApproved: (transfer: Transfer) => Promise<boolean> | boolean;
-}) => Stage;
-/** Refuse while an account is frozen for non-payment. */
-export declare const notFrozenStage: (isFrozen: (owner: string) => Promise<boolean> | boolean) => Stage;