@forgezero/runtime 0.1.13 → 0.1.15

package/dist/compliance.js

@@ -1,168 +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/compliance.ts
-import { Refusal } from "@forgezero/access";
-
-class ComplianceError extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "ComplianceError";
-  }
-}
-var RISK_LEVELS = ["low", "medium", "high", "prohibited"];
-var VERIFICATION_TIERS = ["none", "basic", "verified", "enhanced"];
-var tierLimitRule = (limits) => ({
-  name: "tier.limit",
-  check(subject) {
-    const tier = subject.tier ?? "none";
-    const limit = limits[tier];
-    if (limit === undefined || subject.usdValue === undefined)
-      return;
-    if (subject.usdValue <= limit)
-      return;
-    return {
-      rule: "tier.limit",
-      risk: "high",
-      detail: `$${subject.usdValue} exceeds the $${limit} limit for a ${tier} account.`
-    };
-  }
-});
-var countryRule = (prohibited) => ({
-  name: "country.prohibited",
-  check(subject) {
-    const country = subject.attributes?.country?.toUpperCase();
-    if (!country || !prohibited.includes(country))
-      return;
-    return {
-      rule: "country.prohibited",
-      risk: "prohibited",
-      detail: `${country} is not served.`
-    };
-  }
-});
-var newCounterpartyRule = (args) => ({
-  name: "counterparty.new",
-  async check(subject) {
-    if (!subject.address || (subject.usdValue ?? 0) < args.aboveUsd)
-      return;
-    if (await args.isKnown(subject.address))
-      return;
-    return {
-      rule: "counterparty.new",
-      risk: "medium",
-      detail: `First transfer with ${subject.address.slice(0, 10)}… above $${args.aboveUsd}.`
-    };
-  }
-});
-var ORDER = { low: 0, medium: 1, high: 2, prohibited: 3 };
-var highest = (levels) => levels.reduce((worst, level) => ORDER[level] > ORDER[worst] ? level : worst, "low");
-async function screen(subject, options = {}) {
-  const now = options.now ?? Date.now;
-  if (!subject.owner) {
-    throw new ComplianceError("BAD_SUBJECT", "A subject needs an owner to screen.");
-  }
-  let listMatches = [];
-  let listVersion = "none";
-  if (options.list) {
-    listVersion = options.list.version;
-    listMatches = await options.list.match(subject);
-  }
-  const hits = [];
-  for (const rule of options.rules ?? []) {
-    const hit = await rule.check(subject);
-    if (hit)
-      hits.push(hit);
-  }
-  const risk = highest([
-    ...listMatches.length > 0 ? ["prohibited"] : [],
-    ...hits.map((hit) => hit.risk)
-  ]);
-  const reviewAt = options.reviewAt ?? "high";
-  const decision = risk === "prohibited" ? "refuse" : ORDER[risk] >= ORDER[reviewAt] ? "review" : "allow";
-  return { decision, risk, hits, listMatches, listVersion, screenedAtMs: now(), subject };
-}
-function screeningStage(options = {}) {
-  return {
-    name: "aml.screening",
-    order: 0,
-    async run(transfer) {
-      const subject = {
-        owner: transfer.owner,
-        address: transfer.address,
-        network: transfer.network,
-        direction: transfer.direction,
-        usdValue: Number(transfer.context?.usdValue ?? 0),
-        tier: transfer.context?.tier ?? "none",
-        attributes: transfer.context?.attributes
-      };
-      let verdict;
-      try {
-        verdict = await screen(subject, options);
-      } catch (cause) {
-        if (cause instanceof ComplianceError && cause.code === "LIST_UNAVAILABLE") {
-          throw new Refusal(503, "SCREENING_UNAVAILABLE", "Screening could not be completed. The transfer has not been processed.", {}, true);
-        }
-        throw cause;
-      }
-      await options.record?.(verdict);
-      if (verdict.decision === "refuse") {
-        throw new Refusal(451, "SCREENING_REFUSED", "This transfer cannot be processed.", {
-          risk: verdict.risk,
-          rules: verdict.hits.map((hit) => hit.rule).join(",")
-        });
-      }
-      if (verdict.decision === "review" && !await options.isApproved?.(subject)) {
-        throw new Refusal(409, "SCREENING_REVIEW", "This transfer is held for review.", { risk: verdict.risk }, true);
-      }
-      return { screenedAtMs: verdict.screenedAtMs, risk: verdict.risk, listVersion: verdict.listVersion };
-    }
-  };
-}
-function staticList(entries, version = "static-1") {
-  const byValue = new Map(entries.map((entry) => [entry.value.toLowerCase(), entry]));
-  return {
-    version,
-    async match(subject) {
-      const candidates = [subject.address, subject.attributes?.name, subject.attributes?.country].filter((value) => Boolean(value)).map((value) => value.toLowerCase());
-      return candidates.map((value) => byValue.get(value)).filter((entry) => entry !== undefined);
-    }
-  };
-}
-function combineLists(...lists) {
-  return {
-    version: lists.map((list) => list.version).join("+"),
-    async match(subject) {
-      const all = [];
-      for (const list of lists)
-        all.push(...await list.match(subject));
-      return all;
-    }
-  };
-}
-var unavailableList = (reason) => ({
-  version: "unavailable",
-  async match() {
-    throw new ComplianceError("LIST_UNAVAILABLE", reason);
-  }
-});
-export {
-  unavailableList,
-  tierLimitRule,
-  staticList,
-  screeningStage,
-  screen,
-  newCounterpartyRule,
-  countryRule,
-  combineLists,
-  VERIFICATION_TIERS,
-  RISK_LEVELS,
-  ComplianceError
-};

package/dist/finance/chain-addresses.d.ts

@@ -1,130 +0,0 @@
-import { depositAddress, toChecksumAddress } from './custody';
-import type { AddressScheme, ChainSpec } from './chain';
-/**
- * One deposit address per user per chain, derived rather than allocated.
- *
- * The naive design gives each user a real account created on-chain. That costs
- * gas per user before they have deposited anything, so onboarding a hundred
- * thousand people costs real money for the ones who never fund. Worse, the
- * address list becomes state: lose it and the deposits keep arriving somewhere
- * nobody is watching.
- *
- * A counterfactual CREATE2 address costs nothing. The contract that would live
- * there is not deployed until there is something to sweep out of it, and until
- * then it is a pure function of (factory, salt, init code hash). The whole
- * address book is therefore reproducible from a backup of three values, and
- * "restore the deposit addresses" stops being a recovery procedure at all.
- *
- * ## What this adds over `custody.ts`
- *
- * Almost nothing, deliberately. `custody.depositAddress` already mirrors the
- * deployed factory byte for byte, and `chain.validateAddress` already knows the
- * shape of every scheme. What was missing is the CONVENTION on top: which salt
- * a given user on a given chain gets, and the refusal to answer at all for a
- * chain whose scheme has no counterfactual derivation.
- *
- * Re-exporting rather than reimplementing is the point. Two functions that both
- * compute a deposit address are two chances to disagree, and the one that
- * disagrees sends money somewhere unreachable.
- */
-export { validateAddress, type AddressScheme } from './chain';
-/**
- * Which schemes can derive an address without touching the chain.
- *
- * Only EVM, today. Bitcoin's equivalent is an HD derivation path and Solana's
- * is a program-derived address — both are real designs and neither is this one,
- * so a chain using them must not silently fall through to a formula written for
- * something else. Listing what IS supported rather than excluding what is not
- * means adding a chain fails closed.
- */
-export declare const COUNTERFACTUAL_SCHEMES: readonly AddressScheme[];
-export declare class AddressError extends Error {
-    readonly code: 'SCHEME_UNSUPPORTED' | 'CHAIN_DISABLED' | 'MISSING_DEPLOYMENT' | 'MALFORMED';
-    constructor(code: 'SCHEME_UNSUPPORTED' | 'CHAIN_DISABLED' | 'MISSING_DEPLOYMENT' | 'MALFORMED', message: string);
-}
-/**
- * Where a chain's factory lives, and what it deploys.
- *
- * `proxyInitCodeHash` is read from the DEPLOYED factory rather than compiled in.
- * A Solidity version bump changes the init code and therefore every address
- * derived from it; a hardcoded constant would keep deriving addresses the live
- * factory cannot sweep, and the failure appears only once somebody has already
- * sent funds to one.
- */
-export interface ChainDeployment {
-    chain: string;
-    factory: string;
-    proxyInitCodeHash: string;
-}
-/**
- * The salt for one owner on one chain.
- *
- * The CHAIN is inside the salt even though each chain has its own factory. Two
- * chains that deploy the factory to the same address — which happens, because a
- * deterministic deployer is the normal way to deploy one — would otherwise
- * derive the same deposit address for the same user on both. That is not
- * immediately a loss, but it makes the address ambiguous in every log, alert
- * and support conversation afterwards, and it costs nothing to prevent here.
- */
-export declare const depositSaltFor: (args: {
-    chain: string;
-    owner: string;
-}) => string;
-/**
- * The deposit address for one owner on one chain.
- *
- * Pure: same inputs, same answer, forever. That property is what lets a scanner
- * recompute the whole address book on every pass instead of trusting a stored
- * list, and what makes a stored list a cache rather than a record.
- */
-export declare function deriveDepositAddress(args: {
-    chain: ChainSpec;
-    deployment: ChainDeployment;
-    owner: string;
-}): string;
-/**
- * The raw CREATE2 formula, exposed for anything deriving something else.
- *
- * A thin alias over `custody.depositAddress` so callers with their own salt
- * convention — a per-invoice address, say — do not reach past this module and
- * end up with a second copy of the formula.
- */
-export declare const create2Address: typeof depositAddress;
-/**
- * Every address to watch on one chain, for a set of owners.
- *
- * The scanner needs the whole set on every pass, keyed for lookup rather than
- * listed: matching a block's transfers against an array is a scan per transfer,
- * and a busy block against a large user base is where that becomes the reason a
- * deposit is late.
- *
- * Keyed LOWERCASE. Chains report addresses in whatever case they please, and a
- * checksum-cased key silently fails to match a lowercase one — a deposit that
- * arrives, is seen, and is not credited.
- */
-export declare function depositAddressBook(args: {
-    chain: ChainSpec;
-    deployment: ChainDeployment;
-    owners: readonly string[];
-}): Map<string, string>;
-/**
- * Whose address is this, if anyone's?
- *
- * Case-insensitive for the reason above. Returns `null` rather than throwing:
- * most addresses in any block belong to nobody here, and that is the normal
- * case rather than an error.
- */
-export declare const ownerOfAddress: (book: Map<string, string>, address: string) => string | null;
-/**
- * Check a derived address against what the chain actually reports.
- *
- * Worth doing once per deployment, not per address: if these disagree the
- * formula and the factory have diverged, and every address derived since is
- * wrong. Comparing case-insensitively because the checksum casing is a display
- * convention — a mismatch that is only casing is not a divergence.
- */
-export declare function assertDerivationMatches(args: {
-    derived: string;
-    reportedByChain: string;
-}): void;
-export { toChecksumAddress };