@forgezero/runtime 0.1.14 → 0.1.16

package/contracts/test/Custody.t.sol

@@ -1,361 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.24;
-
-import { DepositFactory } from '../src/DepositFactory.sol';
-import { DepositProxy } from '../src/DepositProxy.sol';
-import { ColdVault } from '../src/ColdVault.sol';
-import { MockToken, MockNoReturnToken, MockFeeToken } from '../src/MockTokens.sol';
-
-/** Foundry cheatcodes, declared inline — this repository does not use submodules. */
-interface Vm {
-	function prank(address) external;
-	function expectRevert(bytes4) external;
-	function expectRevert(bytes calldata) external;
-	function expectRevert() external;
-	function deal(address, uint256) external;
-	function addr(uint256) external pure returns (address);
-	function sign(uint256, bytes32) external pure returns (uint8, bytes32, bytes32);
-	function warp(uint256) external;
-}
-
-contract CustodyTest {
-	Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
-
-	DepositFactory factory;
-	MockToken token;
-	address owner = address(this);
-	address hot = address(0x8074);
-
-	function setUp() public {
-		factory = new DepositFactory(owner);
-		token = new MockToken();
-	}
-
-	/* ================================================== deposit factory === */
-
-	function test_addressIsDerivedWithNoChainWrite() public {
-		// A million deposit addresses cost nothing to derive. This is the whole
-		// advantage over generating and funding a key per address.
-		bytes32 salt = keccak256('anything');
-		address derived = factory.computeAddress(salt);
-		require(derived != address(0), 'derived');
-		require(derived.code.length == 0, 'nothing deployed yet');
-		require(factory.computeAddress(salt) == derived, 'stable');
-	}
-
-	function test_offChainDerivationMatchesTheContract() public {
-		// The formula a platform runs off-chain, computed here from the published
-		// init-code hash. If these ever disagree, deposits go to an address the
-		// platform is not watching.
-		bytes32 salt = keccak256('user:42');
-		address expected = address(
-			uint160(uint256(keccak256(abi.encodePacked(
-				bytes1(0xff), address(factory), salt, factory.PROXY_INIT_CODE_HASH()
-			))))
-		);
-		require(factory.computeAddress(salt) == expected, 'formula matches');
-	}
-
-	function test_theSaltIsOpaque_userOrInvoiceBothWork() public {
-		// The runtime never learns what a salt means. A per-user address and a
-		// per-invoice address are the same primitive with a different convention,
-		// and encoding either here would force it on every platform.
-		bytes32 perUser = keccak256(abi.encodePacked('app:user:', uint256(7)));
-		bytes32 perInvoice = keccak256(abi.encodePacked('app:invoice:', uint256(7)));
-		require(factory.computeAddress(perUser) != factory.computeAddress(perInvoice), 'distinct');
-	}
-
-	function test_sweepNeedsNoApprovalAndNoGasAtTheDepositAddress() public {
-		// The property that makes this design work at all. The deposit address has
-		// no key, no native balance and has never signed anything.
-		bytes32 salt = keccak256('user:1');
-		address deposit = factory.computeAddress(salt);
-		token.mint(deposit, 500);
-		require(deposit.balance == 0, 'no gas at the deposit address');
-
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(token), hot);
-
-		require(token.balanceOf(deposit) == 0, 'collected');
-		require(token.balanceOf(hot) == 500, 'delivered');
-	}
-
-	function test_theProxyIsDeployedLazilyAndOnlyOnce() public {
-		bytes32 salt = keccak256('user:2');
-		address deposit = factory.computeAddress(salt);
-		token.mint(deposit, 100);
-
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(token), hot);
-		require(deposit.code.length > 0, 'deployed on first sweep');
-
-		token.mint(deposit, 100);
-		factory.sweepTo(salts, address(token), hot);
-		require(token.balanceOf(hot) == 200, 'second sweep works');
-	}
-
-	function test_onlyTheFactoryCanSweepAProxy() public {
-		bytes32 salt = keccak256('user:3');
-		address deposit = factory.computeAddress(salt);
-		token.mint(deposit, 100);
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(token), hot);
-
-		// Deployed now — and inert to everybody else.
-		vm.prank(address(0xBAD));
-		vm.expectRevert(DepositProxy.OnlyFactory.selector);
-		DepositProxy(payable(deposit)).sweep(address(token), address(0xBAD));
-	}
-
-	function test_manyAddressesConsolidateInOneTransaction() public {
-		bytes32[] memory salts = new bytes32[](3);
-		for (uint256 i = 0; i < 3; i++) {
-			salts[i] = keccak256(abi.encodePacked('user:', i));
-			token.mint(factory.computeAddress(salts[i]), 100);
-		}
-		factory.sweepTo(salts, address(token), hot);
-		require(token.balanceOf(hot) == 300, 'all three');
-	}
-
-	function test_anAlreadyEmptyAddressDoesNotUndoTheBatch() public {
-		bytes32[] memory salts = new bytes32[](2);
-		salts[0] = keccak256('empty');
-		salts[1] = keccak256('funded');
-		token.mint(factory.computeAddress(salts[1]), 250);
-		factory.sweepTo(salts, address(token), hot);
-		require(token.balanceOf(hot) == 250, 'funded one still swept');
-	}
-
-	function test_nativeCoinSweeps() public {
-		bytes32 salt = keccak256('native');
-		address deposit = factory.computeAddress(salt);
-		vm.deal(deposit, 3 ether);
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(0), hot);
-		require(hot.balance == 3 ether, 'native delivered');
-	}
-
-	function test_usdtStyleTokenSweeps() public {
-		// Returns nothing from transfer. A bool-typed call reverts on decode.
-		MockNoReturnToken usdt = new MockNoReturnToken();
-		bytes32 salt = keccak256('usdt');
-		usdt.mint(factory.computeAddress(salt), 900);
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(usdt), hot);
-		require(usdt.balanceOf(hot) == 900, 'usdt swept');
-	}
-
-	function test_feeOnTransferMovesWhatActuallyArrives() public {
-		// The proxy sweeps its measured balance, so the platform never credits a
-		// figure the token did not deliver.
-		MockFeeToken fee = new MockFeeToken();
-		bytes32 salt = keccak256('fee');
-		fee.mint(factory.computeAddress(salt), 1000);
-		bytes32[] memory salts = new bytes32[](1);
-		salts[0] = salt;
-		factory.sweepTo(salts, address(fee), hot);
-		// 1% on the way to the factory, 1% again on the way out.
-		require(fee.balanceOf(hot) < 1000, 'fee was taken');
-		require(fee.balanceOf(hot) > 970, 'and only the fee');
-	}
-
-	function test_aStrangerCannotSweep() public {
-		bytes32[] memory salts = new bytes32[](0);
-		vm.prank(address(0xBAD));
-		vm.expectRevert(DepositFactory.NotOwner.selector);
-		factory.sweepTo(salts, address(token), hot);
-	}
-}
-
-contract VaultTest {
-	Vm constant vm = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
-
-	ColdVault vault;
-	MockToken token;
-
-	uint256 k1 = 0xA11CE;
-	uint256 k2 = 0xB0B;
-	uint256 k3 = 0xCA401;
-	address c1;
-	address c2;
-	address c3;
-	address operator = address(0x0FF);
-	address payee = address(0xFEE);
-
-	function setUp() public {
-		c1 = vm.addr(k1);
-		c2 = vm.addr(k2);
-		c3 = vm.addr(k3);
-		address[] memory custodians = new address[](3);
-		// Sorted, because signatures must arrive in ascending signer order.
-		(custodians[0], custodians[1], custodians[2]) = _sorted(c1, c2, c3);
-		vault = new ColdVault(custodians, 2);
-		token = new MockToken();
-		token.mint(address(vault), 1_000_000);
-	}
-
-	function _sorted(address a, address b, address c) private pure returns (address, address, address) {
-		address t;
-		if (a > b) { t = a; a = b; b = t; }
-		if (b > c) { t = b; b = c; c = t; }
-		if (a > b) { t = a; a = b; b = t; }
-		return (a, b, c);
-	}
-
-	function _sign(uint256 key, bytes32 digest) private pure returns (bytes memory) {
-		(uint8 v, bytes32 r, bytes32 s) = vm.sign(key, digest);
-		return abi.encodePacked(r, s, v);
-	}
-
-	/** Two signatures, ordered by signer address as the vault requires. */
-	function _quorum(bytes32 digest) private view returns (bytes[] memory out) {
-		out = new bytes[](2);
-		uint256[3] memory keys = [k1, k2, k3];
-		address[3] memory addrs = [c1, c2, c3];
-		// Pick the two lowest addresses so the ordering rule is satisfied.
-		uint256 lowest = 0;
-		for (uint256 i = 1; i < 3; i++) if (addrs[i] < addrs[lowest]) lowest = i;
-		uint256 second = lowest == 0 ? 1 : 0;
-		for (uint256 i = 0; i < 3; i++) {
-			if (i != lowest && addrs[i] < addrs[second]) second = i;
-		}
-		if (second == lowest) second = (lowest + 1) % 3;
-		out[0] = _sign(keys[lowest], digest);
-		out[1] = _sign(keys[second], digest);
-		if (addrs[lowest] > addrs[second]) {
-			bytes memory tmp = out[0]; out[0] = out[1]; out[1] = tmp;
-		}
-	}
-
-	/* ======================================================= cold vault === */
-
-	function test_quorumMovesFunds() public {
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		vault.withdraw(address(token), payee, 5000, _quorum(digest));
-		require(token.balanceOf(payee) == 5000, 'paid');
-	}
-
-	function test_oneSignatureIsNotAQuorum() public {
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory one = new bytes[](1);
-		one[0] = _sign(k1, digest);
-		vm.expectRevert(abi.encodeWithSelector(ColdVault.NotEnoughSignatures.selector, 1, 2));
-		vault.withdraw(address(token), payee, 5000, one);
-	}
-
-	function test_theSameCustodianTwiceIsNotTwoCustodians() public {
-		// Without the ascending-order rule, one custodian submits M copies of
-		// their own approval and an M-of-N vault is a 1-of-N vault.
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory doubled = new bytes[](2);
-		doubled[0] = _sign(k1, digest);
-		doubled[1] = _sign(k1, digest);
-		vm.expectRevert(ColdVault.SignaturesOutOfOrder.selector);
-		vault.withdraw(address(token), payee, 5000, doubled);
-	}
-
-	function test_aStrangersSignatureIsRejected() public {
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory sigs = new bytes[](2);
-		uint256 outsider = 0xDEAD;
-		address outsiderAddr = vm.addr(outsider);
-		// Ordered so the failure is "not a custodian", not the ordering rule.
-		if (outsiderAddr < c1) {
-			sigs[0] = _sign(outsider, digest);
-			sigs[1] = _sign(k1, digest);
-		} else {
-			sigs[0] = _sign(k1, digest);
-			sigs[1] = _sign(outsider, digest);
-		}
-		vm.expectRevert(abi.encodeWithSelector(ColdVault.NotACustodian.selector, outsiderAddr));
-		vault.withdraw(address(token), payee, 5000, sigs);
-	}
-
-	function test_aSpentApprovalCannotBeReplayed() public {
-		// The nonce is what makes a gathered signature spendable once. Without it,
-		// a set of approvals collected today drains the vault forever.
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory sigs = _quorum(digest);
-		vault.withdraw(address(token), payee, 5000, sigs);
-
-		// The nonce moved, so the same bytes now recover to SOME other address --
-		// whichever one, it is not a custodian, and the vault refuses.
-		uint256 before = token.balanceOf(payee);
-		vm.expectRevert();
-		vault.withdraw(address(token), payee, 5000, sigs);
-		require(token.balanceOf(payee) == before, 'nothing moved twice');
-	}
-
-	function test_signaturesDoNotTransferToADifferentAmount() public {
-		// The amount is inside what was signed, so a submitter cannot inflate it.
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory sigs = _quorum(digest);
-		vm.expectRevert();
-		vault.withdraw(address(token), payee, 999_999, sigs);
-		require(token.balanceOf(payee) == 0, 'nothing moved');
-	}
-
-	function test_signaturesDoNotTransferToADifferentDestination() public {
-		bytes32 digest = vault.digestFor(address(token), payee, 5000);
-		bytes[] memory sigs = _quorum(digest);
-		vm.expectRevert();
-		vault.withdraw(address(token), address(0xBAD), 5000, sigs);
-		require(token.balanceOf(address(0xBAD)) == 0, 'nothing moved');
-	}
-
-	function test_signaturesFromAnotherVaultAreVoidHere() public {
-		// `verifyingContract` is in the domain, so approvals gathered for one
-		// deployment cannot be pointed at another.
-		address[] memory custodians = new address[](3);
-		(custodians[0], custodians[1], custodians[2]) = _sorted(c1, c2, c3);
-		ColdVault other = new ColdVault(custodians, 2);
-		token.mint(address(other), 10_000);
-
-		bytes32 otherDigest = other.digestFor(address(token), payee, 5000);
-		bytes[] memory sigs = _quorum(otherDigest);
-		vm.expectRevert();
-		vault.withdraw(address(token), payee, 5000, sigs);
-		require(token.balanceOf(payee) == 0, 'nothing moved');
-	}
-
-	function test_aThresholdOfOneIsRefused() public {
-		address[] memory custodians = new address[](3);
-		(custodians[0], custodians[1], custodians[2]) = _sorted(c1, c2, c3);
-		vm.expectRevert(ColdVault.BadThreshold.selector);
-		new ColdVault(custodians, 1);
-	}
-
-	function test_aThresholdAboveTheSetIsRefused() public {
-		// A vault nobody can ever open is not more secure, it is destroyed.
-		address[] memory custodians = new address[](2);
-		custodians[0] = c1 < c2 ? c1 : c2;
-		custodians[1] = c1 < c2 ? c2 : c1;
-		vm.expectRevert(ColdVault.BadThreshold.selector);
-		new ColdVault(custodians, 3);
-	}
-
-	function test_nobodyCanRotateCustodiansWithoutTheQuorum() public {
-		address[] memory next = new address[](2);
-		next[0] = address(0x1);
-		next[1] = address(0x2);
-		vm.expectRevert(ColdVault.OnlySelf.selector);
-		vault.setCustodians(next, 2);
-	}
-
-	/* ------------------------------------------------------------------------
-	 * There is no hot vault, deliberately.
-	 *
-	 * A hot wallet is an ADDRESS, not a contract. The factory already holds float
-	 * and already sweeps to any destination, so a separate contract to hold
-	 * working capital adds a deployment, an upgrade path and a second set of
-	 * permissions without adding a property neither of these already has.
-	 *
-	 * Operational funds sit at whatever address the platform sweeps to; the cold
-	 * vault holds what M-of-N custodians guard. Two things, each doing one job.
-	 * ---------------------------------------------------------------------- */
-}

package/contracts/test/Vectors.t.sol

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.24;
-
-import { DepositFactory } from '../src/DepositFactory.sol';
-import { ColdVault } from '../src/ColdVault.sol';
-
-/**
- * Emit values the TypeScript client must reproduce.
- *
- * The client mirrors two pure contract functions. Checking it against itself
- * proves nothing — a formula wrong the same way every time is deterministic and
- * still points a platform at an address the factory cannot sweep.
- */
-contract VectorsTest {
-	function test_emitVectors() public {
-		// A fixed owner so the factory address is stable across runs.
-		DepositFactory factory = new DepositFactory(address(0xF00D));
-
-		bytes32 salt = keccak256(abi.encodePacked('myapp:user:', 'u1'));
-
-		address[] memory custodians = new address[](3);
-		custodians[0] = address(0x1111111111111111111111111111111111111111);
-		custodians[1] = address(0x2222222222222222222222222222222222222222);
-		custodians[2] = address(0x3333333333333333333333333333333333333333);
-		ColdVault vault = new ColdVault(custodians, 2);
-
-		bytes32 digest = vault.digestFor(
-			address(0xdAC17F958D2ee523a2206206994597C13D831ec7),
-			address(0x000000000000000000000000000000000000dEaD),
-			1_000_000
-		);
-
-		// Read from the trace; the TS test asserts against these.
-		require(factory.computeAddress(salt) != address(0), 'derived');
-		emit Vector('factory', abi.encode(address(factory)));
-		emit Vector('proxyInitCodeHash', abi.encode(factory.PROXY_INIT_CODE_HASH()));
-		emit Vector('salt', abi.encode(salt));
-		emit Vector('depositAddress', abi.encode(factory.computeAddress(salt)));
-		emit Vector('vault', abi.encode(address(vault)));
-		emit Vector('chainId', abi.encode(block.chainid));
-		emit Vector('withdrawDigest', abi.encode(digest));
-	}
-
-	event Vector(string name, bytes value);
-}

package/dist/compliance.d.ts

@@ -1,172 +0,0 @@
-/**
- * Screening — the stage that already has a seat.
- *
- * `@forgezero/runtime/finance/transfers` reserved position zero and has been running a
- * pass-everything placeholder there since before this file existed. That
- * ordering is the whole reason this is a drop-in: nothing about deposits or
- * withdrawals changes, and the audit trail already records the stage running.
- *
- * ## Screening is a DECISION RECORD, not a boolean
- *
- * The value of compliance work six months later is being able to say why a
- * transfer was allowed — not just that it was. A screen that returns true or
- * false gives an auditor nothing, so every check produces a verdict with the
- * rules that fired, the risk it scored and the list version it was screened
- * against. That record is the deliverable; the refusal is a side effect.
- *
- * ## Fail CLOSED on an unavailable list, and say so
- *
- * A sanctions list that cannot be reached is not "no hits". Treating an
- * unreachable provider as a pass is how sanctioned money moves during an
- * outage, and it is invisible afterwards because the trail says allowed. So an
- * unavailable list refuses with a retryable status — the transfer waits rather
- * than proceeding unscreened.
- *
- * ## What this deliberately does NOT do
- *
- * No list is bundled. A sanctions list embedded in a package is out of date the
- * day it publishes, and being out of date is the only failure mode that
- * matters. The provider is injected, and `staticList` exists for tests and for
- * an operator's own denylist — never as the primary source.
- */
-export declare class ComplianceError extends Error {
-    readonly code: 'LIST_UNAVAILABLE' | 'BAD_SUBJECT';
-    constructor(code: 'LIST_UNAVAILABLE' | 'BAD_SUBJECT', message: string);
-}
-export declare const RISK_LEVELS: readonly ["low", "medium", "high", "prohibited"];
-export type RiskLevel = (typeof RISK_LEVELS)[number];
-export declare const VERIFICATION_TIERS: readonly ["none", "basic", "verified", "enhanced"];
-export type VerificationTier = (typeof VERIFICATION_TIERS)[number];
-export interface Subject {
-    /** The account being screened. */
-    owner: string;
-    /** Counterparty address, for a transfer. */
-    address?: string;
-    network?: string;
-    /** Value in USD, so a threshold rule can fire. */
-    usdValue?: number;
-    direction?: 'deposit' | 'withdrawal';
-    /** How far the account has verified. Drives the tier rules. */
-    tier?: VerificationTier;
-    /** Anything a rule wants — country, name, date of birth. */
-    attributes?: Record<string, string>;
-}
-export interface ListEntry {
-    /** Address, name or identifier this entry matches. */
-    value: string;
-    kind: 'address' | 'name' | 'country';
-    /** Which list it came from — OFAC, an internal denylist, a chain analytics feed. */
-    source: string;
-    reason?: string;
-}
-export interface ScreeningList {
-    /** Bumped whenever the list content changes. Recorded on every verdict. */
-    readonly version: string;
-    /** Throws `ComplianceError('LIST_UNAVAILABLE')` rather than returning empty. */
-    match(subject: Subject): Promise<ListEntry[]>;
-}
-export interface RuleHit {
-    rule: string;
-    risk: RiskLevel;
-    detail: string;
-}
-export interface Rule {
-    name: string;
-    /** Returns a hit, or undefined when the rule does not fire. */
-    check(subject: Subject): RuleHit | undefined | Promise<RuleHit | undefined>;
-}
-/**
- * A transfer above a threshold for the tier the account has reached.
- *
- * Tiered rather than one global limit, because the whole point of verification
- * is that it raises what an account may move. A single threshold means either
- * verified accounts are throttled or unverified ones are not.
- */
-export declare const tierLimitRule: (limits: Partial<Record<VerificationTier, number>>) => Rule;
-/** A jurisdiction the platform will not serve. */
-export declare const countryRule: (prohibited: readonly string[]) => Rule;
-/**
- * A deposit from an address that has never been seen, above a threshold.
- *
- * Weak on its own and useful in combination — it is the kind of signal that
- * raises a transfer to review rather than refusing it, which is why it scores
- * `medium` and not higher.
- */
-export declare const newCounterpartyRule: (args: {
-    aboveUsd: number;
-    isKnown: (address: string) => boolean | Promise<boolean>;
-}) => Rule;
-export interface Verdict {
-    decision: 'allow' | 'review' | 'refuse';
-    risk: RiskLevel;
-    hits: RuleHit[];
-    listMatches: ListEntry[];
-    /** Which list version this was screened against. The auditable part. */
-    listVersion: string;
-    screenedAtMs: number;
-    subject: Subject;
-}
-export interface ScreenOptions {
-    list?: ScreeningList;
-    rules?: readonly Rule[];
-    /** At or above this, the transfer is held for a human rather than refused. */
-    reviewAt?: RiskLevel;
-    now?: () => number;
-}
-/**
- * Screen a subject and produce a verdict.
- *
- * A list match is always `prohibited` — that is what a sanctions list means,
- * and softening it to "high risk, review it" is the decision nobody should be
- * able to make quietly in a config file. Rules can only ever raise the level
- * arrived at, never lower it.
- */
-export declare function screen(subject: Subject, options?: ScreenOptions): Promise<Verdict>;
-export interface StageOptions extends ScreenOptions {
-    /** Called for every verdict, allowed or not. The case record. */
-    record?: (verdict: Verdict) => void | Promise<void>;
-    /** Whether a `review` verdict has already been approved by a human. */
-    isApproved?: (subject: Subject) => boolean | Promise<boolean>;
-}
-/**
- * The screening stage, shaped for `@forgezero/runtime/finance/transfers`.
- *
- * Drops into the seat that was reserved at order zero. Nothing else changes —
- * which was the entire point of building the pipeline before the policy.
- *
- * EVERY verdict is recorded, including allowances. A trail of refusals answers
- * "what did we stop" and not "what did we decide", and the second question is
- * the one an auditor asks.
- */
-export declare function screeningStage(options?: StageOptions): {
-    name: string;
-    order: number;
-    run(transfer: {
-        owner: string;
-        direction: "deposit" | "withdrawal";
-        address?: string;
-        network?: string;
-        amount: {
-            units: bigint;
-            asset: string;
-        };
-        context?: Record<string, unknown>;
-    }): Promise<{
-        screenedAtMs: number;
-        risk: "low" | "medium" | "high" | "prohibited";
-        listVersion: string;
-    }>;
-};
-/**
- * A list held in memory.
- *
- * For tests, and for an operator's own denylist alongside a real feed — never
- * as the primary source. A sanctions list bundled into a package is out of date
- * the day it publishes, and being out of date is the only failure mode that
- * matters here.
- */
-export declare function staticList(entries: readonly ListEntry[], version?: string): ScreeningList;
-/** Combine several lists. Any one being unavailable fails the whole screen. */
-export declare function combineLists(...lists: readonly ScreeningList[]): ScreeningList;
-/** A list that is not configured yet. Refuses, so nothing runs unscreened by accident. */
-export declare const unavailableList: (reason: string) => ScreeningList;