@forgezero/runtime 0.1.0

package/dist/finance/chain-withdrawals.js

@@ -0,0 +1,631 @@
+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/ledger.ts
+class LedgerError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "LedgerError";
+  }
+}
+var BUCKETS = ["available", "held"];
+var ACCOUNT_KINDS = ["user", "platform", "external"];
+var accountId = (account) => `${account.kind}:${account.owner}:${account.bucket ?? "available"}`;
+function parseAccount(id) {
+  const [kind, owner, bucket] = id.split(":");
+  return { kind, owner, bucket };
+}
+var queueKeyFor = (account) => `${account.kind}:${account.owner}`;
+function assertBalanced(transaction) {
+  if (transaction.entries.length === 0) {
+    throw new LedgerError("EMPTY_TRANSACTION", "A transaction needs at least two entries.");
+  }
+  const totals = new Map;
+  for (const entry of transaction.entries) {
+    if (entry.amount.units === 0n) {
+      throw new LedgerError("ZERO_ENTRY", `An entry on ${accountId(entry.account)} moves nothing. Remove it or give it an amount.`);
+    }
+    totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
+  }
+  for (const [asset, total] of totals) {
+    if (total !== 0n) {
+      throw new LedgerError("UNBALANCED", `${asset} does not sum to zero — it is off by ${total} minor units. Every movement needs a counterparty.`);
+    }
+  }
+}
+function transfer(args) {
+  const transaction = {
+    reference: args.reference,
+    kind: args.kind,
+    atMs: args.atMs,
+    memo: args.memo,
+    entries: [
+      { account: args.from, amount: { units: -args.amount.units, asset: args.amount.asset } },
+      { account: args.to, amount: args.amount }
+    ]
+  };
+  assertBalanced(transaction);
+  return transaction;
+}
+var placeHold = (args) => transfer({
+  reference: args.reference,
+  kind: "hold.place",
+  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
+  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
+  amount: args.amount,
+  atMs: args.atMs,
+  memo: args.memo
+});
+var releaseHold = (args) => transfer({
+  reference: args.reference,
+  kind: "hold.release",
+  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
+  to: { kind: args.kind ?? "user", owner: args.owner, bucket: "available" },
+  amount: args.amount,
+  atMs: args.atMs
+});
+var captureHold = (args) => transfer({
+  reference: args.reference,
+  kind: "hold.capture",
+  from: { kind: args.kind ?? "user", owner: args.owner, bucket: "held" },
+  to: args.to,
+  amount: args.amount,
+  atMs: args.atMs,
+  memo: args.memo
+});
+function balancesFrom(transactions) {
+  const balances = new Map;
+  for (const transaction of transactions) {
+    for (const entry of transaction.entries) {
+      const id = accountId(entry.account);
+      const perAsset = balances.get(id) ?? new Map;
+      const current = perAsset.get(entry.amount.asset) ?? zero(entry.amount.asset);
+      perAsset.set(entry.amount.asset, add(current, entry.amount));
+      balances.set(id, perAsset);
+    }
+  }
+  return balances;
+}
+function balanceOf(balances, account, asset) {
+  return balances.get(accountId(account))?.get(asset) ?? zero(asset);
+}
+var availableOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "available" }, asset);
+var heldOf = (balances, owner, asset, kind = "user") => balanceOf(balances, { kind, owner, bucket: "held" }, asset);
+var totalOf = (balances, owner, asset, kind = "user") => add(availableOf(balances, owner, asset, kind), heldOf(balances, owner, asset, kind));
+function trialBalance(transactions) {
+  const totals = new Map;
+  const accounts = new Map;
+  for (const transaction of transactions) {
+    for (const entry of transaction.entries) {
+      totals.set(entry.amount.asset, (totals.get(entry.amount.asset) ?? 0n) + entry.amount.units);
+      const seen = accounts.get(entry.amount.asset) ?? new Set;
+      seen.add(accountId(entry.account));
+      accounts.set(entry.amount.asset, seen);
+    }
+  }
+  const perAsset = [...totals.entries()].map(([asset, total]) => ({
+    asset,
+    total,
+    accounts: accounts.get(asset)?.size ?? 0
+  }));
+  const discrepancies = perAsset.filter((row) => row.total !== 0n).map((row) => ({ asset: row.asset, off: row.total }));
+  return { ok: discrepancies.length === 0, perAsset, discrepancies };
+}
+function statement(transactions, account, asset) {
+  const id = accountId(account);
+  let running = zero(asset);
+  return [...transactions].sort((a, b) => a.atMs - b.atMs).flatMap((transaction) => transaction.entries.filter((entry) => accountId(entry.account) === id && entry.amount.asset === asset).map((entry) => {
+    running = add(running, entry.amount);
+    return {
+      atMs: transaction.atMs,
+      reference: transaction.reference,
+      kind: transaction.kind,
+      amount: formatAmount(entry.amount, { trim: true }),
+      balance: formatAmount(running, { trim: true })
+    };
+  }));
+}
+function assertAvailable(balances, args) {
+  const available = availableOf(balances, args.owner, args.amount.asset, args.kind ?? "user");
+  if (subtract(available, args.amount).units < 0n) {
+    throw new LedgerError("INSUFFICIENT_AVAILABLE", `${args.owner} has ${formatAmount(available, { trim: true })} ${args.amount.asset} available; this needs ${formatAmount(args.amount, { trim: true })}.`);
+  }
+}
+var VERSION2 = "0.1.0";
+
+// src/finance/chain.ts
+class ChainError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChainError";
+  }
+}
+var ADDRESS_SCHEMES = ["evm", "bitcoin", "tron", "solana"];
+var SCHEME_PATTERNS = {
+  evm: /^0x[a-fA-F0-9]{40}$/,
+  bitcoin: /^(bc1[a-z0-9]{25,62}|[13][a-km-zA-HJ-NP-Z1-9]{25,34})$/,
+  tron: /^T[a-zA-Z0-9]{33}$/,
+  solana: /^[1-9A-HJ-NP-Za-km-z]{32,44}$/
+};
+function validateAddress(address, chain) {
+  if (!SCHEME_PATTERNS[chain.scheme].test(address.trim())) {
+    throw new ChainError("BAD_ADDRESS", `"${address.slice(0, 12)}…" is not a valid ${chain.label} address. Check you have not pasted an address for a different chain — that is the mistake that cannot be undone.`);
+  }
+}
+function assertChain(chain) {
+  if (chain.confirmations.length === 0) {
+    throw new ChainError("BAD_CONFIRMATIONS", `${chain.key} declares no confirmation depth.`);
+  }
+  if (chain.confirmations[0].aboveUsd !== 0) {
+    throw new ChainError("BAD_CONFIRMATIONS", `${chain.key} must have a band starting at 0, or small transfers match no rule.`);
+  }
+  let previous = -1;
+  for (const band of chain.confirmations) {
+    if (band.aboveUsd <= previous) {
+      throw new ChainError("BAD_CONFIRMATIONS", `${chain.key} bands must ascend; ${band.aboveUsd} follows ${previous}.`);
+    }
+    if (!Number.isInteger(band.confirmations) || band.confirmations < 1) {
+      throw new ChainError("BAD_CONFIRMATIONS", `${chain.key} band above $${band.aboveUsd} needs at least one confirmation.`);
+    }
+    previous = band.aboveUsd;
+  }
+}
+function confirmationsFor(chain, usdValue) {
+  let depth = chain.confirmations[0].confirmations;
+  for (const band of chain.confirmations) {
+    if (usdValue >= band.aboveUsd)
+      depth = band.confirmations;
+  }
+  return depth;
+}
+var estimatedSeconds = (chain, usdValue) => confirmationsFor(chain, usdValue) * chain.blockSeconds;
+function createChainRegistry(args) {
+  for (const chain of args.chains)
+    assertChain(chain);
+  const chains = new Map(args.chains.map((chain) => [chain.key, chain]));
+  return {
+    all: () => [...chains.values()].filter((chain) => chain.enabled),
+    byKey(key) {
+      const chain = chains.get(key);
+      if (!chain)
+        throw new ChainError("UNKNOWN_CHAIN", `No chain "${key}" is configured.`);
+      return chain;
+    },
+    assetsOn: (chain) => args.assets.filter((asset) => asset.chain === chain && asset.enabled),
+    chainsFor: (asset) => args.assets.filter((entry) => entry.asset === asset && entry.enabled).map((entry) => chains.get(entry.chain)).filter((chain) => chain?.enabled === true),
+    asset(chain, asset) {
+      const entry = args.assets.find((row) => row.chain === chain && row.asset === asset);
+      if (!entry) {
+        throw new ChainError("UNKNOWN_ASSET", `${asset} is not configured on ${chain}.`);
+      }
+      assetSpec(asset);
+      return entry;
+    },
+    explorerTx: (chain, hash) => {
+      const spec = chains.get(chain);
+      return spec ? `${spec.explorerTx}${hash}` : hash;
+    },
+    explorerAddress: (chain, address) => {
+      const spec = chains.get(chain);
+      return spec ? `${spec.explorerAddress}${address}` : address;
+    },
+    validate(chain, address) {
+      validateAddress(address, this.byKey(chain));
+    }
+  };
+}
+var SEED_CHAINS = [
+  {
+    key: "bsc",
+    label: "BNB Smart Chain",
+    scheme: "evm",
+    chainId: 56,
+    nativeAsset: "BNB",
+    blockSeconds: 3,
+    confirmations: [
+      { aboveUsd: 0, confirmations: 15 },
+      { aboveUsd: 1e4, confirmations: 30 },
+      { aboveUsd: 1e5, confirmations: 60 }
+    ],
+    explorerTx: "https://bscscan.com/tx/",
+    explorerAddress: "https://bscscan.com/address/",
+    enabled: true
+  },
+  {
+    key: "ethereum",
+    label: "Ethereum",
+    scheme: "evm",
+    chainId: 1,
+    nativeAsset: "ETH",
+    blockSeconds: 12,
+    confirmations: [
+      { aboveUsd: 0, confirmations: 12 },
+      { aboveUsd: 50000, confirmations: 32 }
+    ],
+    explorerTx: "https://etherscan.io/tx/",
+    explorerAddress: "https://etherscan.io/address/",
+    enabled: true
+  },
+  {
+    key: "tron",
+    label: "Tron",
+    scheme: "tron",
+    nativeAsset: "TRX",
+    blockSeconds: 3,
+    confirmations: [{ aboveUsd: 0, confirmations: 20 }],
+    explorerTx: "https://tronscan.org/#/transaction/",
+    explorerAddress: "https://tronscan.org/#/address/",
+    enabled: true
+  }
+];
+var SEED_CHAIN_ASSETS = [
+  { chain: "bsc", asset: "BNB", minDeposit: "0.001", enabled: true },
+  {
+    chain: "bsc",
+    asset: "USDT",
+    contract: "0x55d398326f99059ff775485246999027b3197955",
+    minDeposit: "1",
+    enabled: true
+  },
+  { chain: "ethereum", asset: "ETH", minDeposit: "0.005", enabled: true },
+  {
+    chain: "ethereum",
+    asset: "USDT",
+    contract: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    minDeposit: "20",
+    enabled: true
+  },
+  {
+    chain: "tron",
+    asset: "USDT",
+    contract: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+    minDeposit: "1",
+    enabled: true
+  }
+];
+
+// src/finance/chain-withdrawals.ts
+class WithdrawalError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "WithdrawalError";
+  }
+}
+var WITHDRAWAL_STATES = [
+  "requested",
+  "approved",
+  "dispatched",
+  "confirmed",
+  "rejected",
+  "failed",
+  "refunded"
+];
+var TRANSITIONS = {
+  requested: ["approved", "rejected"],
+  approved: ["dispatched", "rejected"],
+  dispatched: ["confirmed", "failed"],
+  confirmed: [],
+  rejected: [],
+  failed: ["refunded"],
+  refunded: []
+};
+var canTransition = (from, to) => TRANSITIONS[from].includes(to);
+function assertTransition(withdrawal, to) {
+  if (!canTransition(withdrawal.state, to)) {
+    throw new WithdrawalError("BAD_STATE", `A withdrawal cannot go from ${withdrawal.state} to ${to}. ` + `From ${withdrawal.state} the only moves are: ${TRANSITIONS[withdrawal.state].join(", ") || "none"}.`);
+  }
+}
+var holdReference = (key) => `withdrawal:hold:${key}`;
+var broadcastKeyFor = (withdrawal) => `withdrawal:send:${withdrawal.chain}:${withdrawal.key}`;
+function requestWithdrawal(args) {
+  if (!args.key?.trim())
+    throw new WithdrawalError("MALFORMED", "A withdrawal needs a key.");
+  if (!args.chain.enabled) {
+    throw new WithdrawalError("CHAIN_DISABLED", `${args.chain.label} is not processing withdrawals.`);
+  }
+  if (args.amount.units <= 0n) {
+    throw new WithdrawalError("BAD_AMOUNT", "A withdrawal is for a positive amount.");
+  }
+  try {
+    validateAddress(args.destination, args.chain);
+  } catch (cause) {
+    throw new WithdrawalError("BAD_ADDRESS", `That is not a ${args.chain.label} address. ${cause instanceof Error ? cause.message : ""}`.trim());
+  }
+  if (args.available.asset !== args.amount.asset) {
+    throw new WithdrawalError("MALFORMED", "The available balance is in a different asset.");
+  }
+  if (args.available.units < args.amount.units) {
+    throw new WithdrawalError("INSUFFICIENT", "That is more than the available balance.");
+  }
+  return {
+    withdrawal: {
+      key: args.key,
+      owner: args.owner,
+      chain: args.chain.key,
+      destination: args.destination,
+      amount: args.amount,
+      state: "requested",
+      requestedAtMs: args.atMs
+    },
+    hold: placeHold({
+      reference: holdReference(args.key),
+      owner: args.owner,
+      amount: args.amount,
+      atMs: args.atMs
+    })
+  };
+}
+function approveWithdrawal(withdrawal, args) {
+  assertTransition(withdrawal, "approved");
+  if (!args.actorUserKey?.trim()) {
+    throw new WithdrawalError("MALFORMED", "An approval is always attributed.");
+  }
+  return {
+    ...withdrawal,
+    state: "approved",
+    decidedByUserKey: args.actorUserKey,
+    broadcastKey: broadcastKeyFor(withdrawal)
+  };
+}
+function rejectWithdrawal(withdrawal, args) {
+  assertTransition(withdrawal, "rejected");
+  if (!args.reason?.trim()) {
+    throw new WithdrawalError("MALFORMED", "A rejection carries a reason — the customer is told it.");
+  }
+  return {
+    withdrawal: {
+      ...withdrawal,
+      state: "rejected",
+      decidedByUserKey: args.actorUserKey,
+      reason: args.reason
+    },
+    release: releaseHold({
+      reference: `withdrawal:release:${withdrawal.key}`,
+      owner: withdrawal.owner,
+      amount: withdrawal.amount,
+      atMs: args.atMs
+    })
+  };
+}
+async function processOnce(withdrawal, args) {
+  assertTransition(withdrawal, "dispatched");
+  const broadcastKey = withdrawal.broadcastKey ?? broadcastKeyFor(withdrawal);
+  const sent = await args.broadcaster.send({
+    broadcastKey,
+    chain: withdrawal.chain,
+    destination: withdrawal.destination,
+    amount: withdrawal.amount
+  });
+  return { ...withdrawal, state: "dispatched", broadcastKey, txHash: sent.txHash };
+}
+function confirmWithdrawal(withdrawal, args) {
+  assertTransition(withdrawal, "confirmed");
+  return {
+    withdrawal: { ...withdrawal, state: "confirmed", txHash: args.txHash },
+    capture: captureHold({
+      reference: `withdrawal:capture:${withdrawal.key}`,
+      owner: withdrawal.owner,
+      to: { kind: "external", owner: withdrawal.chain, bucket: "available" },
+      amount: withdrawal.amount,
+      atMs: args.atMs
+    })
+  };
+}
+function markFailed(withdrawal, args) {
+  assertTransition(withdrawal, "failed");
+  return { ...withdrawal, state: "failed", reason: args.reason };
+}
+function refundFailed(withdrawal, args) {
+  assertTransition(withdrawal, "refunded");
+  return {
+    withdrawal: { ...withdrawal, state: "refunded" },
+    release: releaseHold({
+      reference: `withdrawal:refund:${withdrawal.key}`,
+      owner: withdrawal.owner,
+      amount: withdrawal.amount,
+      atMs: args.atMs
+    })
+  };
+}
+function sweepForPayout(args) {
+  const asset = args.need.asset;
+  if (args.hot.asset !== asset) {
+    throw new WithdrawalError("MALFORMED", "The hot balance is in a different asset.");
+  }
+  const sweep = [];
+  const uneconomic = [];
+  let raised = args.hot.units;
+  const ordered = [...args.candidates].sort((a, b) => b.amount.units > a.amount.units ? 1 : -1);
+  for (const candidate of ordered) {
+    if (candidate.amount.asset !== asset)
+      continue;
+    const net = candidate.amount.units - candidate.estimatedGas.units;
+    if (net <= 0n) {
+      uneconomic.push(candidate);
+      continue;
+    }
+    if (raised >= args.need.units)
+      break;
+    sweep.push(candidate);
+    raised += net;
+  }
+  return {
+    sweep,
+    uneconomic,
+    raised: { units: raised, asset },
+    short: raised < args.need.units
+  };
+}
+var describeSweep = (plan) => `${plan.sweep.length} address(es) to sweep, ${plan.uneconomic.length} not worth the gas` + (plan.short ? " — still short of the payout" : "");
+export {
+  sweepForPayout,
+  requestWithdrawal,
+  rejectWithdrawal,
+  refundFailed,
+  processOnce,
+  markFailed,
+  holdReference,
+  describeSweep,
+  confirmWithdrawal,
+  canTransition,
+  broadcastKeyFor,
+  approveWithdrawal,
+  WithdrawalError,
+  WITHDRAWAL_STATES
+};