cascrow-signer 0.1.0

package/dist/calldata.js

@@ -0,0 +1,121 @@
+/**
+ * The contract as the signer sees it: ABI, acceptance domain and types, escrow
+ * IDs, and calldata built HERE from the ABI — never taken from a server.
+ *
+ * The ABI is a byte copy of the app's generated file (src/lib/abi/
+ * milestone-escrow-v3.json). `escrowIdFor`, `acceptanceDomain` and the
+ * acceptance types are ports of src/lib/escrow-v3.ts; signer-artifact-parity.test.ts
+ * runs both on the same inputs.
+ *
+ * Canonical arguments (the `call.args` form of a prepared transaction, design
+ * Rev. 10): ABI order, integers as decimal strings, bytes and addresses as
+ * lowercase 0x hex, tuples as objects keyed by component name.
+ */
+import { createRequire } from "node:module";
+import { AbiCoder, Interface, ZeroAddress, getAddress, isAddress, keccak256 } from "ethers";
+import { refuse } from "./errors.js";
+const require = createRequire(import.meta.url);
+const artifact = require("./generated/milestone-escrow-v3.json");
+export const ESCROW_V3_INTERFACE = new Interface(artifact.abi);
+export const V3_PHASE_NAMES = Object.freeze([...artifact.phases]);
+export const V3_LIMITS = Object.freeze({
+    MIN_REVIEW_SECONDS: artifact.constants.MIN_REVIEW,
+    MAX_REVIEW_SECONDS: artifact.constants.MAX_REVIEW,
+    MIN_ARBITRATION_SECONDS: artifact.constants.MIN_ARB,
+    MAX_ARBITRATION_SECONDS: artifact.constants.MAX_ARB,
+    MAX_DEADLINE_SECONDS: artifact.constants.MAX_DEADLINE_DURATION,
+    MAX_CLAIMS: artifact.constants.MAX_CLAIMS,
+});
+export const ACCEPTANCE_TYPES = Object.freeze(structuredClone(artifact.eip712.types));
+export const ACCEPTANCE_PRIMARY_TYPE = artifact.eip712.primaryType;
+const BYTES32 = /^0x[0-9a-fA-F]{64}$/;
+/** keccak256(abi.encode(payer, ref, salt)) — the contract's `escrowIdFor`. */
+export function escrowIdFor(payer, ref, salt) {
+    if (!isAddress(payer))
+        throw new Error("payer must be an address");
+    if (!BYTES32.test(ref))
+        throw new Error("ref must be a 0x-prefixed 32-byte hex string");
+    if (!BYTES32.test(salt))
+        throw new Error("salt must be a 0x-prefixed 32-byte hex string");
+    return keccak256(AbiCoder.defaultAbiCoder().encode(["address", "bytes32", "bytes32"], [payer, ref, salt]));
+}
+/** The domain a payee signs under — the PINNED chain and contract, never the server's. */
+export function acceptanceDomain(chainId, verifyingContract) {
+    return { name: artifact.eip712.name, version: artifact.eip712.version, chainId, verifyingContract: getAddress(verifyingContract) };
+}
+/** The contract function each action calls. `resolve` is the arbiter's and is not offered. */
+export const ACTION_FN = Object.freeze({
+    fund: "fund",
+    submitClaim: "submitClaim",
+    claim: "claim",
+    release: "release",
+    object: "object",
+    refund: "refund",
+    extendDeadline: "extendDeadline",
+    returnFunds: "returnFunds",
+    withdraw: "withdraw",
+});
+export const SIGNER_ACTIONS = Object.freeze(Object.keys(ACTION_FN));
+/** Actions whose first argument is the escrow ID. */
+export const PER_ESCROW_ACTIONS = new Set(["submitClaim", "claim", "release", "object", "refund", "extendDeadline", "returnFunds"]);
+function canonicalValue(t, v) {
+    if (t.baseType === "tuple") {
+        const out = {};
+        const comps = t.components ?? [];
+        comps.forEach((c, i) => {
+            const src = v;
+            out[c.name] = canonicalValue(c, src[c.name] !== undefined ? src[c.name] : src[i]);
+        });
+        return out;
+    }
+    if (t.baseType === "array")
+        return v.map((x) => canonicalValue(t.arrayChildren, x));
+    if (t.baseType.startsWith("uint") || t.baseType.startsWith("int"))
+        return BigInt(v).toString(10);
+    if (t.baseType === "bool")
+        return Boolean(v);
+    return String(v).toLowerCase();
+}
+/** Canonical form of `args` for `fn`, whatever shape (ethers Result, strings, bigints) they come in. */
+export function canonicalArgs(fn, args) {
+    const f = ESCROW_V3_INTERFACE.getFunction(fn);
+    if (!f)
+        refuse("UNKNOWN_FUNCTION", `the escrow contract has no function ${fn}`);
+    if (!Array.isArray(args) || args.length !== f.inputs.length)
+        refuse("ARGS_SHAPE", `${fn} takes ${f.inputs.length} arguments`);
+    return f.inputs.map((p, i) => canonicalValue(p, args[i]));
+}
+/** Calldata for `fn(args)`, encoded from the pinned ABI. */
+export function encodeCall(fn, args) {
+    return ESCROW_V3_INTERFACE.encodeFunctionData(fn, canonicalArgs(fn, args)).toLowerCase();
+}
+/** Decode calldata into its function name and canonical arguments. */
+export function decodeCall(data) {
+    const parsed = ESCROW_V3_INTERFACE.parseTransaction({ data });
+    if (!parsed)
+        refuse("UNKNOWN_FUNCTION", "calldata does not call a MilestoneEscrowV3 function");
+    return { fn: parsed.name, args: canonicalArgs(parsed.name, parsed.args.toArray(true)) };
+}
+export function sameCanonical(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export const ZERO_ADDRESS = ZeroAddress;
+export function decodeGetEscrow(result) {
+    const [t] = ESCROW_V3_INTERFACE.decodeFunctionResult("getEscrow", result);
+    const n = (x) => Number(x);
+    return {
+        payer: getAddress(t.payer),
+        deadline: n(t.deadline),
+        reviewPeriod: n(t.reviewPeriod),
+        payee: getAddress(t.payee),
+        claimedAt: n(t.claimedAt),
+        claimCount: n(t.claimCount),
+        objected: Boolean(t.objected),
+        status: n(t.status),
+        arbiter: getAddress(t.arbiter),
+        objectedAt: n(t.objectedAt),
+        arbitrationPeriod: n(t.arbitrationPeriod),
+        token: getAddress(t.token),
+        amount: BigInt(t.amount),
+    };
+}

package/dist/chain.d.ts

@@ -0,0 +1,59 @@
+import type { ChainEscrow } from "./calldata.js";
+import { Rpc } from "./network.js";
+import type { SignerNetwork } from "./network.js";
+import { Journal } from "./journal.js";
+import type { UnlockedKey } from "./keystore.js";
+export type ChainCtx = {
+    rpc: Rpc;
+    net: SignerNetwork;
+};
+export declare function readEscrow(c: ChainCtx, escrowId: string): Promise<ChainEscrow>;
+export declare function readCredit(c: ChainCtx, account: string): Promise<bigint>;
+export declare function latestBlock(c: ChainCtx): Promise<{
+    number: number;
+    timestamp: number;
+    baseFee: bigint | null;
+}>;
+/** Every `Funded(payer = me)` in the last 24 h of CHAIN time: escrowId → amount. Throws when the chain cannot be read. */
+export declare function fundedByMeLastDay(c: ChainCtx, me: string, chainNow: {
+    number: number;
+    timestamp: number;
+}): Promise<Map<string, bigint>>;
+/** ClaimSubmitted events for one escrow, oldest first. */
+export declare function claimsOf(c: ChainCtx, escrowId: string, fromBlock: number, toBlock: number): Promise<{
+    claimIndex: number;
+    proofHash: string;
+    claimedAt: number;
+    objectionDeadline: number;
+    block: number;
+}[]>;
+/** A contract revert, named by the contract's own error, or null. */
+export declare function revertName(e: unknown): string | null;
+export type SendResult = {
+    txHash: string;
+    nonce: number;
+    sent: boolean;
+    note?: string;
+};
+/**
+ * Estimate, sign locally and send to the pinned public RPC. Call inside `withLock`,
+ * after the reservation was written. The raw signed transaction exists only in
+ * this function's scope and in the RPC request body — it is never returned,
+ * logged or sent anywhere else.
+ */
+export declare function sendSigned(c: ChainCtx, key: UnlockedKey, journal: Journal, reservationId: string, tx: {
+    to: string;
+    data: string;
+    value: bigint;
+}): Promise<SendResult>;
+/**
+ * Replace a pending transaction of this key with the same nonce and fees raised by
+ * 25 % — the way to speed up an objection, instead of waiting. Refused once the
+ * nonce is used.
+ */
+export declare function speedUp(c: ChainCtx, key: UnlockedKey, journal: Journal, txHash: string): Promise<SendResult>;
+/**
+ * Release reservations whose transaction provably spent nothing: signed, outcome
+ * unknown, its nonce now used, and no receipt for any of its hashes.
+ */
+export declare function settleUnknown(c: ChainCtx, me: string, journal: Journal): Promise<void>;

package/dist/chain.js

@@ -0,0 +1,233 @@
+/**
+ * Reading the escrow from the chain and putting a signed transaction on the wire
+ * — both through the pinned network's own RPC (network.ts), never through cascrow.
+ *
+ * `sendSigned` must run INSIDE `withLock` (journal.ts): nonce, reservation,
+ * signature and send are one critical section, so two sends never take the same
+ * nonce and two fundings never both pass the daily limit.
+ */
+import { ZeroAddress, getAddress, keccak256, toBeHex, zeroPadValue } from "ethers";
+import { refuse } from "./errors.js";
+import { ESCROW_V3_INTERFACE, decodeGetEscrow } from "./calldata.js";
+import { RpcError, verifyEndpoint } from "./network.js";
+import { DAY_SECONDS } from "./journal.js";
+async function ethCall(c, fn, args) {
+    return c.rpc.call("eth_call", [{ to: c.net.address, data: ESCROW_V3_INTERFACE.encodeFunctionData(fn, args) }, "latest"]);
+}
+export async function readEscrow(c, escrowId) {
+    return decodeGetEscrow(await ethCall(c, "getEscrow", [escrowId]));
+}
+export async function readCredit(c, account) {
+    const [v] = ESCROW_V3_INTERFACE.decodeFunctionResult("credit", await ethCall(c, "credit", [account, ZeroAddress]));
+    return BigInt(v);
+}
+export async function latestBlock(c) {
+    const b = await c.rpc.call("eth_getBlockByNumber", ["latest", false]);
+    if (!b || typeof b.timestamp !== "string")
+        refuse("CHAIN_UNREADABLE", "the RPC returned no latest block");
+    return { number: Number(BigInt(b.number)), timestamp: Number(BigInt(b.timestamp)), baseFee: b.baseFeePerGas ? BigInt(b.baseFeePerGas) : null };
+}
+async function blockTime(c, n) {
+    const b = await c.rpc.call("eth_getBlockByNumber", [toBeHex(n), false]);
+    if (!b)
+        refuse("CHAIN_UNREADABLE", `the RPC returned no block ${n}`);
+    return Number(BigInt(b.timestamp));
+}
+/** First block whose timestamp is after `cutoff`, searched between the deploy block and `latest`. */
+async function firstBlockAfter(c, cutoff, latest) {
+    let lo = c.net.deployBlock;
+    let hi = latest;
+    while (lo < hi) {
+        const mid = Math.floor((lo + hi) / 2);
+        if ((await blockTime(c, mid)) > cutoff)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return lo;
+}
+const LOG_CHUNK = 10_000;
+/** Every `Funded(payer = me)` in the last 24 h of CHAIN time: escrowId → amount. Throws when the chain cannot be read. */
+export async function fundedByMeLastDay(c, me, chainNow) {
+    const from = await firstBlockAfter(c, chainNow.timestamp - DAY_SECONDS, chainNow.number);
+    const topic0 = ESCROW_V3_INTERFACE.getEvent("Funded").topicHash;
+    const payerTopic = zeroPadValue(getAddress(me), 32).toLowerCase();
+    const out = new Map();
+    for (let start = from; start <= chainNow.number; start += LOG_CHUNK) {
+        const end = Math.min(chainNow.number, start + LOG_CHUNK - 1);
+        const logs = await c.rpc.call("eth_getLogs", [
+            { address: c.net.address, fromBlock: toBeHex(start), toBlock: toBeHex(end), topics: [topic0, null, payerTopic] },
+        ]);
+        for (const l of logs ?? []) {
+            if (l.address.toLowerCase() !== c.net.address.toLowerCase())
+                continue;
+            const parsed = ESCROW_V3_INTERFACE.parseLog(l);
+            if (!parsed || parsed.name !== "Funded" || getAddress(parsed.args.payer) !== getAddress(me))
+                continue;
+            out.set(String(parsed.args.escrowId).toLowerCase(), BigInt(parsed.args.amount));
+        }
+    }
+    return out;
+}
+/** ClaimSubmitted events for one escrow, oldest first. */
+export async function claimsOf(c, escrowId, fromBlock, toBlock) {
+    const topic0 = ESCROW_V3_INTERFACE.getEvent("ClaimSubmitted").topicHash;
+    const out = [];
+    for (let start = Math.max(fromBlock, c.net.deployBlock); start <= toBlock; start += LOG_CHUNK) {
+        const end = Math.min(toBlock, start + LOG_CHUNK - 1);
+        const logs = await c.rpc.call("eth_getLogs", [
+            { address: c.net.address, fromBlock: toBeHex(start), toBlock: toBeHex(end), topics: [topic0, escrowId.toLowerCase()] },
+        ]);
+        for (const l of logs ?? []) {
+            const p = ESCROW_V3_INTERFACE.parseLog(l);
+            if (!p)
+                continue;
+            out.push({
+                claimIndex: Number(p.args.claimIndex),
+                proofHash: String(p.args.proofHash),
+                claimedAt: Number(p.args.claimedAt),
+                objectionDeadline: Number(p.args.objectionDeadline),
+                block: Number(BigInt(l.blockNumber)),
+            });
+        }
+    }
+    return out;
+}
+/** A contract revert, named by the contract's own error, or null. */
+export function revertName(e) {
+    const data = e instanceof RpcError ? e.data : null;
+    const hex = typeof data === "string" ? data : data && typeof data === "object" && typeof data.data === "string" ? data.data : null;
+    if (!hex)
+        return null;
+    try {
+        return ESCROW_V3_INTERFACE.parseError(hex)?.name ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+const pct = (v, p) => (v * BigInt(p)) / BigInt(100);
+async function feeFields(c, bumpFrom) {
+    const b = await latestBlock(c);
+    if (b.baseFee !== null) {
+        let prio;
+        try {
+            prio = BigInt(await c.rpc.call("eth_maxPriorityFeePerGas"));
+        }
+        catch {
+            prio = BigInt(1_000_000_000);
+        }
+        let maxFee = b.baseFee * BigInt(2) + prio;
+        if (bumpFrom?.maxFeePerGas) {
+            prio = [prio, pct(BigInt(bumpFrom.maxPriorityFeePerGas), 125)].reduce((a, x) => (a > x ? a : x));
+            maxFee = [maxFee, pct(BigInt(bumpFrom.maxFeePerGas), 125)].reduce((a, x) => (a > x ? a : x));
+        }
+        return { type: 2, maxPriorityFeePerGas: prio, maxFeePerGas: maxFee };
+    }
+    let gasPrice = BigInt(await c.rpc.call("eth_gasPrice"));
+    if (bumpFrom?.gasPrice)
+        gasPrice = [gasPrice, pct(BigInt(bumpFrom.gasPrice), 125)].reduce((a, x) => (a > x ? a : x));
+    return { type: 0, gasPrice };
+}
+/**
+ * Estimate, sign locally and send to the pinned public RPC. Call inside `withLock`,
+ * after the reservation was written. The raw signed transaction exists only in
+ * this function's scope and in the RPC request body — it is never returned,
+ * logged or sent anywhere else.
+ */
+export async function sendSigned(c, key, journal, reservationId, tx) {
+    await verifyEndpoint(c.rpc, c.net);
+    if (getAddress(tx.to) !== getAddress(c.net.address))
+        refuse("WRONG_TARGET", "the signer only ever sends to the pinned escrow contract");
+    const from = key.address;
+    let gas;
+    try {
+        gas = BigInt(await c.rpc.call("eth_estimateGas", [{ from, to: tx.to, data: tx.data, value: toBeHex(tx.value) }]));
+    }
+    catch (e) {
+        journal.release(reservationId, "gas estimation failed before signing");
+        const name = revertName(e);
+        refuse("WOULD_REVERT", `the contract would reject this transaction${name ? `: ${name}` : ""}; nothing was signed`);
+    }
+    const nonce = Number(BigInt(await c.rpc.call("eth_getTransactionCount", [from, "pending"])));
+    const fees = await feeFields(c);
+    const fields = { chainId: c.net.chainId, nonce, to: tx.to, data: tx.data, value: tx.value, gasLimit: pct(gas, 125), ...fees };
+    const signed = await key.signTransaction(fields);
+    const hash = keccak256(signed);
+    journal.signed(reservationId, hash, nonce, Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, typeof v === "bigint" ? v.toString() : v])));
+    try {
+        const answered = await c.rpc.call("eth_sendRawTransaction", [signed]);
+        if (typeof answered === "string" && answered.toLowerCase() !== hash.toLowerCase()) {
+            journal.unknown(reservationId, hash, "the RPC answered a different hash");
+            return { txHash: hash, nonce, sent: false, note: "the RPC answered a different transaction hash — check your account before sending again" };
+        }
+        journal.sent(reservationId, hash);
+        return { txHash: hash, nonce, sent: true };
+    }
+    catch (e) {
+        // The answer was lost or refused. The transaction may still be in a mempool:
+        // the reservation keeps counting until its nonce is used. Never resend blindly.
+        journal.unknown(reservationId, hash, e instanceof Error ? e.message : "send failed");
+        return { txHash: hash, nonce, sent: false, note: "the send's outcome is unknown — do not send again; check the hash, or speed it up with the same nonce" };
+    }
+}
+/**
+ * Replace a pending transaction of this key with the same nonce and fees raised by
+ * 25 % — the way to speed up an objection, instead of waiting. Refused once the
+ * nonce is used.
+ */
+export async function speedUp(c, key, journal, txHash) {
+    await verifyEndpoint(c.rpc, c.net);
+    const r = journal.read().find((x) => x.signed && (x.signed.hash.toLowerCase() === txHash.toLowerCase() || x.sentHashes.some((h) => h.toLowerCase() === txHash.toLowerCase())));
+    if (!r || !r.signed)
+        refuse("NOT_IN_JOURNAL", "this transaction was not signed by this signer");
+    const used = Number(BigInt(await c.rpc.call("eth_getTransactionCount", [key.address, "latest"])));
+    if (used > r.signed.nonce)
+        refuse("NONCE_USED", "that transaction's nonce is already used — it was mined or replaced");
+    const prev = r.signed.tx;
+    const fees = await feeFields(c, prev);
+    const fields = {
+        chainId: c.net.chainId,
+        nonce: r.signed.nonce,
+        to: prev.to,
+        data: prev.data,
+        value: BigInt(prev.value),
+        gasLimit: BigInt(prev.gasLimit),
+        ...fees,
+    };
+    if (getAddress(fields.to) !== getAddress(c.net.address))
+        refuse("WRONG_TARGET", "the journal entry does not target the pinned contract");
+    const signed = await key.signTransaction(fields);
+    const hash = keccak256(signed);
+    journal.signed(r.id, hash, r.signed.nonce, Object.fromEntries(Object.entries(fields).map(([k, v]) => [k, typeof v === "bigint" ? v.toString() : v])));
+    try {
+        await c.rpc.call("eth_sendRawTransaction", [signed]);
+        journal.sent(r.id, hash);
+        return { txHash: hash, nonce: r.signed.nonce, sent: true };
+    }
+    catch (e) {
+        journal.unknown(r.id, hash, e instanceof Error ? e.message : "send failed");
+        return { txHash: hash, nonce: r.signed.nonce, sent: false, note: "the replacement's outcome is unknown" };
+    }
+}
+/**
+ * Release reservations whose transaction provably spent nothing: signed, outcome
+ * unknown, its nonce now used, and no receipt for any of its hashes.
+ */
+export async function settleUnknown(c, me, journal) {
+    const open = journal.read().filter((r) => r.unknown && !r.released && r.signed);
+    if (!open.length)
+        return;
+    const used = Number(BigInt(await c.rpc.call("eth_getTransactionCount", [me, "latest"])));
+    for (const r of open) {
+        if (used <= r.signed.nonce)
+            continue;
+        const hashes = [r.signed.hash, ...r.sentHashes];
+        let mined = false;
+        for (const h of hashes)
+            if (await c.rpc.call("eth_getTransactionReceipt", [h]))
+                mined = true;
+        if (!mined)
+            journal.release(r.id, "nonce used by another transaction");
+    }
+}

package/dist/checks.d.ts

@@ -0,0 +1,101 @@
+import type { ChainEscrow, SignerAction } from "./calldata.js";
+import type { V3ChainFacts, V3EscrowAction } from "./generated/v3-actions.js";
+import type { Policy } from "./policy.js";
+import type { BookEntry } from "./book.js";
+export type PreparedTx = {
+    chainId: number;
+    to: string;
+    value: string;
+    data: string;
+    call: {
+        fn: string;
+        args: unknown[];
+    };
+    escrowId: string;
+    action: string;
+    role: string;
+    expect: {
+        phase: string;
+        from: string;
+    };
+    deadline?: string;
+};
+export type Pinned = {
+    chainId: number;
+    address: string;
+};
+/**
+ * The envelope of a prepared transaction against what the signer knows: chain and
+ * contract from its own pinned config, the sender from its own key, the function
+ * from the action it was asked to perform, and `data` re-encoded from the ABI.
+ */
+export declare function checkPreparedEnvelope(p: unknown, action: SignerAction, pinned: Pinned, me: string): PreparedTx;
+/** A locally built call and the server's prepared one must be the same transaction. */
+export declare function checkMatchesLocal(local: {
+    to: string;
+    data: string;
+    value: bigint;
+}, p: PreparedTx): void;
+export type FundTerms = {
+    ref: string;
+    salt: string;
+    t: {
+        payee: string;
+        token: string;
+        amount: bigint;
+        deadline: bigint;
+        reviewPeriod: number;
+        arbiter: string;
+        arbitrationPeriod: number;
+        acceptBy: bigint;
+    };
+    payeeSig: string;
+};
+export declare function fundTermsFrom(p: PreparedTx): FundTerms;
+/** Who signed this acceptance, under the PINNED domain (never the server's). Null when it does not recover. */
+export declare function acceptanceSigner(pinned: Pinned, escrowId: string, t: FundTerms["t"], sig: string): string | null;
+/** Seconds a fund needs between signing and `acceptBy` so it can still land. */
+export declare const ACCEPT_BY_MARGIN_SECONDS = 120;
+export type FundCheckInput = {
+    prepared: PreparedTx;
+    terms: FundTerms;
+    me: string;
+    pinned: Pinned;
+    policy: Policy;
+    /** Already committed in the rolling 24 h window (journal ∪ chain). */
+    daySumWei: bigint;
+    /** Latest block timestamp — CHAIN time, not the local clock. */
+    chainNowSec: number;
+    /** What the escrow slot holds on chain right now (0 = None). */
+    slotStatus: number;
+    /** Optional upper bound the caller named for this one funding. */
+    maxAmountWei?: bigint | null;
+};
+/** The local invariants for `fund` (design Rev. 10, "Lokale Invarianten für fund"). Returns whether the payee is a known counterparty. */
+export declare function checkFund(i: FundCheckInput): {
+    payeeKnown: boolean;
+    limitWei: bigint;
+};
+export declare function chainFacts(e: ChainEscrow): V3ChainFacts;
+/**
+ * Actions the payer may only sign for an escrow in the local book: the two that
+ * move the payer's money TOWARDS the payee or lengthen its lock. `object` is not
+ * one of them: it is the payer's veto with a clock, it moves nothing, and it is
+ * gated on the CHAIN alone (the on-chain payer must be this key) — a deleted or
+ * tampered book must never cost a payer the objection window (post-review H1).
+ * Only these actions read the book at all; every other action reads it, if at
+ * all, only to find an escrow ID, and a broken book is a loud note there.
+ */
+export declare const BOOK_BOUND_ACTIONS: ReadonlySet<SignerAction>;
+/**
+ * A post-funding action against the CHAIN's record of the escrow and the chain's
+ * clock: the app's role × phase matrix, the local book for the payer's money
+ * moves, and the action's own argument.
+ */
+export declare function checkEscrowAction(action: V3EscrowAction, me: string, e: ChainEscrow, chainNowSec: number, opts: {
+    book: BookEntry | null;
+    newDeadline?: bigint | null;
+    proofHash?: string | null;
+    reasonHash?: string | null;
+}): void;
+export declare function checkWithdraw(me: string, credit: bigint): void;