@myzonerocks/pact 0.1.0

package/dist/src/client.js

@@ -0,0 +1,510 @@
+import { randomBytes } from "node:crypto";
+import { State } from "./state.js";
+import { Money } from "./money.js";
+import { DEFAULT_SKEW_MILLIS, domain } from "./protocol.js";
+import { CanonicalWriter, hashPreimage } from "./canonical.js";
+import { intentHash, quoteHash, authorizationHash, corridorReceipt, isDirect, BRIDGE_PASSTHROUGH, } from "./message.js";
+import { authorize as signAuthorization, verifyAuthorization } from "./signing.js";
+import { PassThroughBridge } from "./bridge.js";
+import { railInList } from "./leg.js";
+import { route, PolicyKind, NoQuoteError, isExpired } from "./router.js";
+import { permissiveKyc, allowRisk, withinLimits } from "./compliance.js";
+import { MemoryLedger, eventReceipt } from "./ledger.js";
+export function systemClock() {
+    return Date.now();
+}
+export function randomId() {
+    return Buffer.from(randomBytes(16)).toString("hex");
+}
+// Client is the corridor orchestrator a host embeds. It mints intents, composes
+// corridor quotes across legs and bridges, authorizes with the host's signer,
+// and runs collect -> convert -> disburse, folding each step into the ledger. It
+// never holds funds and never touches transport.
+export class Client {
+    payIn = new Map();
+    payOut = new Map();
+    bridges = new Map();
+    ledger;
+    policy;
+    verifier;
+    kyc;
+    risk;
+    clock;
+    idGen;
+    skew;
+    escrowRef;
+    subscribers = [];
+    constructor(cfg) {
+        for (const l of cfg.payIn ?? [])
+            this.payIn.set(l.id, l);
+        for (const l of cfg.payOut ?? [])
+            this.payOut.set(l.id, l);
+        for (const b of cfg.bridges ?? [])
+            this.bridges.set(b.id, b);
+        if (this.bridges.size === 0) {
+            this.bridges.set(BRIDGE_PASSTHROUGH, new PassThroughBridge());
+        }
+        this.ledger = cfg.ledger ?? new MemoryLedger();
+        this.policy = cfg.policy ?? { kind: PolicyKind.Cheapest };
+        this.verifier = cfg.verifier;
+        this.kyc = cfg.kyc ?? permissiveKyc;
+        this.risk = cfg.risk ?? allowRisk;
+        this.clock = cfg.clock ?? systemClock;
+        this.idGen = cfg.idGen ?? randomId;
+        this.skew = cfg.skew ?? DEFAULT_SKEW_MILLIS;
+        this.escrowRef = cfg.escrowRef ?? "";
+    }
+    // createIntent mints an intent and records it as a draft.
+    createIntent(spec) {
+        const intent = {
+            id: this.idGen(),
+            senderRef: spec.senderRef,
+            recipientRef: spec.recipientRef,
+            amount: spec.amount,
+            memo: spec.memo ?? "",
+            expiresAt: spec.expiresAt,
+            allowedRails: spec.allowedRails ?? [],
+            metadata: spec.metadata ?? {},
+        };
+        this.ledger.apply({ intentId: intent.id, to: State.Draft, payloadHash: intentHash(intent), intent });
+        return intent;
+    }
+    // quoteOptions composes a corridor quote for each way the payer offered to fund
+    // the payment. For every funding option it finds a bridge that can reach the
+    // recipient's currency and a pay-out leg that can deliver it, prices the whole
+    // corridor, and returns the options for the payer to choose among.
+    async quoteOptions(intent, funding) {
+        const quotes = [];
+        let lastErr;
+        for (const f of funding) {
+            const payInLeg = this.payIn.get(f.payInAdapterId);
+            if (!payInLeg) {
+                lastErr = new Error(`pact: no pay-in leg ${JSON.stringify(f.payInAdapterId)}`);
+                continue;
+            }
+            if (!containsOrEmpty(payInLeg.payInCapabilities().currencies, f.currency)) {
+                lastErr = new Error(`pact: pay-in leg ${JSON.stringify(f.payInAdapterId)} does not fund ${f.currency}`);
+                continue;
+            }
+            try {
+                quotes.push(await this.composeQuote(intent, payInLeg, f));
+            }
+            catch (err) {
+                lastErr = err;
+            }
+        }
+        if (quotes.length === 0) {
+            if (lastErr instanceof Error)
+                throw lastErr;
+            throw new NoQuoteError("no fundable corridor");
+        }
+        return quotes;
+    }
+    // composeQuote prices one corridor: a pay-out leg delivers the recipient's
+    // currency, a bridge plans the source needed from the payer's currency, and the
+    // leg and bridge fees are summed into what the payer pays.
+    async composeQuote(intent, payInLeg, f) {
+        const payOutLeg = this.pickPayOut(intent);
+        const bridge = this.pickBridge(f.currency, intent.amount.currency);
+        const bridged = await bridge.quote(intent.amount, f.currency, f.exponent);
+        const src = bridged.srcAmount.add(bridged.fee);
+        return {
+            id: this.idGen(),
+            intentId: intent.id,
+            payInAdapterId: payInLeg.id,
+            payInRail: firstRail(payInLeg.payInCapabilities().rails),
+            payOutAdapterId: payOutLeg.id,
+            payOutRail: this.payOutRail(payOutLeg, intent),
+            bridgeId: bridge.id,
+            srcAmount: src,
+            dstAmount: intent.amount,
+            fees: bridged.fee,
+            fxRate: bridged.fxRate,
+            expiresAt: intent.expiresAt,
+            providerQuoteRef: "",
+            latencyEstimateMs: 0,
+        };
+    }
+    // pickPayOut finds a pay-out leg that delivers the recipient's currency on an
+    // allowed rail.
+    pickPayOut(intent) {
+        for (const leg of this.payOut.values()) {
+            const caps = leg.payOutCapabilities();
+            if (!containsOrEmpty(caps.currencies, intent.amount.currency))
+                continue;
+            if (this.payOutRail(leg, intent) !== "")
+                return leg;
+        }
+        throw new NoQuoteError("no pay-out leg for the recipient's currency and rails");
+    }
+    // payOutRail returns the rail this leg would use for the intent, or empty if
+    // none of the intent's allowed rails are served.
+    payOutRail(leg, intent) {
+        const caps = leg.payOutCapabilities();
+        if (intent.allowedRails.length === 0)
+            return firstRail(caps.rails);
+        for (const rail of intent.allowedRails) {
+            if (railInList(caps.rails, rail))
+                return rail;
+        }
+        return "";
+    }
+    // pickBridge selects a bridge that converts the payer's currency to the
+    // recipient's. Same-currency prefers pass-through; otherwise a converting
+    // bridge.
+    pickBridge(srcCurrency, dstCurrency) {
+        if (srcCurrency === dstCurrency) {
+            const passThrough = this.bridges.get(BRIDGE_PASSTHROUGH);
+            if (passThrough)
+                return passThrough;
+        }
+        for (const b of this.bridges.values()) {
+            if (b.id !== BRIDGE_PASSTHROUGH)
+                return b;
+        }
+        const passThrough = this.bridges.get(BRIDGE_PASSTHROUGH);
+        if (passThrough && srcCurrency === dstCurrency)
+            return passThrough;
+        throw new NoQuoteError(`no bridge from ${srcCurrency} to ${dstCurrency}`);
+    }
+    // select applies the configured policy to a set of corridor quotes.
+    async select(quotes, identity) {
+        const status = await this.kyc.status(identity);
+        return route(quotes, this.policy, status, this.clock(), this.skew);
+    }
+    // authorize records the chosen corridor, runs the risk hook, signs the sender's
+    // commitment, and records the authorization, advancing draft -> quoted ->
+    // authorized.
+    async authorize(intent, quote, signer) {
+        if (quote.intentId !== intent.id) {
+            throw new Error("pact: quote does not belong to intent");
+        }
+        const now = this.clock();
+        if (isExpired(intent.expiresAt, now, this.skew)) {
+            throw new Error("pact: intent has expired");
+        }
+        if (isExpired(quote.expiresAt, now, this.skew)) {
+            throw new Error("pact: quote has expired");
+        }
+        const status = await this.kyc.status(signer.identity());
+        if (!withinLimits(status, quote)) {
+            throw new Error("pact: quote exceeds KYC limit");
+        }
+        const decision = this.risk.evaluate(signer.identity(), intent, quote);
+        if (!decision.allow) {
+            throw new Error(`pact: risk hook vetoed authorization: ${decision.reason}`);
+        }
+        this.ledger.apply({ intentId: intent.id, to: State.Quoted, payloadHash: quoteHash(quote), quote });
+        const auth = signAuthorization(intent, quote, signer, now);
+        const authHash = authorizationHash(intentHash(intent), quoteHash(quote), auth.signerIdentity, auth.signedAt);
+        this.ledger.apply({ intentId: intent.id, to: State.Authorized, payloadHash: authHash, authorization: auth });
+        return auth;
+    }
+    // initiate starts a corridor and returns its in-flight state. It verifies the
+    // authorization, kicks off the pay-in leg, records the state, and returns
+    // immediately — it does not wait for the provider to confirm. Settlement is
+    // driven forward by advance as provider events arrive, so no promise or
+    // connection is held open per payment and durable state lives only in the
+    // ledger.
+    async initiate(intent, quote, auth) {
+        verifyAuthorization(auth, intent, quote, this.verifier);
+        const payInLeg = this.payIn.get(quote.payInAdapterId);
+        if (!payInLeg) {
+            throw new Error(`pact: no pay-in leg ${JSON.stringify(quote.payInAdapterId)}`);
+        }
+        // A direct corridor collects straight to the recipient; a bridged one
+        // collects into escrow first.
+        let deliverTo = recipientDestination(intent);
+        let to = State.Submitted;
+        if (!isDirect(quote)) {
+            deliverTo = this.escrowRef;
+            to = State.Collecting;
+        }
+        const collected = await payInLeg.collect(intent.id, quote, auth, deliverTo);
+        this.ledger.apply({ intentId: intent.id, to, payloadHash: submitHash(collected.providerRef), collect: collected });
+        return to;
+    }
+    // advance resumes a corridor when a provider event arrives — a webhook, a
+    // callback, a chain receipt, already normalized into an AdapterEvent. It reads
+    // the corridor's state from the ledger, interprets the event against it, and
+    // moves it forward one hop. It returns the terminal settlement once reached and
+    // the resulting state. Advancing the same step twice is idempotent, so a
+    // duplicated webhook settles once.
+    async advance(intentId, adapterId, event) {
+        const events = this.ledger.events(intentId);
+        const replayed = replay(events);
+        if (!replayed) {
+            throw new Error("pact: intent has no recorded authorization to advance");
+        }
+        const { intent, quote, authorization: auth } = replayed;
+        const authHash = authorizationHash(intentHash(intent), quoteHash(quote), auth.signerIdentity, auth.signedAt);
+        const current = this.ledger.state(intentId);
+        const failed = event.state === State.Failed;
+        const fromPayIn = adapterId === quote.payInAdapterId;
+        const fromPayOut = adapterId === quote.payOutAdapterId;
+        // A direct corridor's pay-in confirms and it settles.
+        if (fromPayIn && current === State.Submitted) {
+            if (failed)
+                return this.recordFailure(intentId, authHash, quote, event.reason);
+            const ref = payInRef(events);
+            const settlement = {
+                intentId,
+                state: State.Settled,
+                adapterId: quote.payInAdapterId,
+                providerTxRef: ref,
+                onchainTxHash: "",
+                receiptHash: corridorReceipt(authHash, ref, ref, quote.fxRate, "", State.Settled),
+                reason: "",
+                settledAt: this.clock(),
+            };
+            return this.finishAdvance(intentId, State.Settled, settlement);
+        }
+        // A bridged corridor's pay-in confirms; hold, convert, and kick off the
+        // pay-out.
+        if (fromPayIn && current === State.Collecting) {
+            // Nothing has entered escrow, so a failure here is a plain failure.
+            if (failed)
+                return this.recordFailure(intentId, authHash, quote, event.reason);
+            return this.holdAndDisburse(intent, quote, authHash, events);
+        }
+        // The pay-out confirms and the corridor settles, or fails and unwinds.
+        if (fromPayOut && current === State.Disbursing) {
+            if (failed)
+                return this.unwind(intentId, quote, authHash, event.reason);
+            return this.settleBridged(intentId, quote, authHash, events);
+        }
+        // Any other event — a duplicate webhook, or one for a phase already past — is
+        // a no-op. This is what makes a re-delivered provider callback settle once.
+        return { settlement: lastSettlement(events), state: current };
+    }
+    // holdAndDisburse records the escrow hold, converts through the bridge, and
+    // kicks off the pay-out leg, leaving the corridor disbursing until its pay-out
+    // confirms.
+    async holdAndDisburse(intent, quote, authHash, events) {
+        const payOutLeg = this.payOut.get(quote.payOutAdapterId);
+        if (!payOutLeg) {
+            throw new Error(`pact: no pay-out leg ${JSON.stringify(quote.payOutAdapterId)}`);
+        }
+        const bridge = this.bridges.get(quote.bridgeId);
+        if (!bridge) {
+            throw new Error(`pact: no bridge ${JSON.stringify(quote.bridgeId)}`);
+        }
+        const collected = collectResult(events);
+        this.ledger.apply({
+            intentId: intent.id,
+            to: State.Held,
+            payloadHash: hashString(domain("held"), collected.providerRef),
+        });
+        let converted;
+        try {
+            converted = await bridge.convert(intent.id, collected.received, intent.amount.currency, intent.amount.exponent);
+        }
+        catch (err) {
+            return this.unwind(intent.id, quote, authHash, reasonOf(err));
+        }
+        let disbursed;
+        try {
+            disbursed = await payOutLeg.disburse(intent.id, quote, recipientDestination(intent));
+        }
+        catch (err) {
+            return this.unwind(intent.id, quote, authHash, reasonOf(err));
+        }
+        const marker = {
+            intentId: intent.id,
+            state: State.Disbursing,
+            adapterId: payOutLeg.id,
+            providerTxRef: disbursed.providerRef,
+            onchainTxHash: "",
+            receiptHash: new Uint8Array(0),
+            reason: "",
+            settledAt: 0,
+        };
+        this.ledger.apply({
+            intentId: intent.id,
+            to: State.Disbursing,
+            payloadHash: hashString(domain("disburse"), disbursed.providerRef),
+            settlement: marker,
+            bridge: converted,
+        });
+        return { settlement: emptySettlement(), state: State.Disbursing };
+    }
+    // settleBridged closes out a bridged corridor once its pay-out has confirmed,
+    // binding both legs and the FX into the linked receipt.
+    settleBridged(intentId, quote, authHash, events) {
+        const inRef = payInRef(events);
+        const { payOut: outRef, bridge: bridgeRef } = disburseRefs(events);
+        const settlement = {
+            intentId,
+            state: State.Settled,
+            adapterId: quote.payOutAdapterId,
+            providerTxRef: outRef,
+            onchainTxHash: "",
+            receiptHash: corridorReceipt(authHash, inRef, outRef, quote.fxRate, bridgeRef, State.Settled),
+            reason: "",
+            settledAt: this.clock(),
+        };
+        return this.finishAdvance(intentId, State.Settled, settlement);
+    }
+    // unwind refunds the payer from escrow when a bridged corridor cannot complete
+    // its pay-out, moving to refunding then refunded.
+    async unwind(intentId, quote, authHash, reason) {
+        this.ledger.apply({
+            intentId,
+            to: State.Refunding,
+            payloadHash: hashString(domain("refunding"), reason),
+        });
+        const payInLeg = this.payIn.get(quote.payInAdapterId);
+        if (payInLeg) {
+            await payInLeg.refundIn(intentId, payInLeg.payInCapabilities().refunds, reason);
+        }
+        const settlement = {
+            intentId,
+            state: State.Refunded,
+            adapterId: quote.payInAdapterId,
+            providerTxRef: "",
+            onchainTxHash: "",
+            receiptHash: corridorReceipt(authHash, "", "", quote.fxRate, "", State.Refunded),
+            reason,
+            settledAt: this.clock(),
+        };
+        return this.finishAdvance(intentId, State.Refunded, settlement);
+    }
+    // recordFailure marks a pay-in that failed before any escrow was taken.
+    recordFailure(intentId, authHash, quote, reason) {
+        const settlement = {
+            intentId,
+            state: State.Failed,
+            adapterId: quote.payInAdapterId,
+            providerTxRef: "",
+            onchainTxHash: "",
+            receiptHash: corridorReceipt(authHash, "", "", quote.fxRate, "", State.Failed),
+            reason,
+            settledAt: this.clock(),
+        };
+        return this.finishAdvance(intentId, State.Failed, settlement);
+    }
+    finishAdvance(intentId, state, settlement) {
+        const finished = this.finish(intentId, state, settlement);
+        return { settlement: finished, state };
+    }
+    finish(intentId, state, settlement) {
+        const event = this.ledger.apply({ intentId, to: state, payloadHash: settlement.receiptHash, settlement });
+        this.notify(event);
+        return settlement;
+    }
+    // expire records that an intent's deadline passed before it settled.
+    expire(intentId) {
+        this.ledger.apply({
+            intentId,
+            to: State.Expired,
+            payloadHash: eventReceipt(0, intentId, State.Expired, new Uint8Array(0)),
+        });
+    }
+    subscribe(handler) {
+        this.subscribers.push(handler);
+    }
+    history(intentId) {
+        return this.ledger.events(intentId);
+    }
+    state(intentId) {
+        return this.ledger.state(intentId);
+    }
+    head(intentId) {
+        return this.ledger.head(intentId);
+    }
+    notify(event) {
+        for (const h of this.subscribers)
+            h(event);
+    }
+}
+// recipientDestination is the rail-specific handle the pay-out lands on — a
+// crypto address, a phone number — carried in metadata, falling back to the
+// generic recipient reference.
+export function recipientDestination(intent) {
+    const d = intent.metadata["recipient_destination"];
+    return d ? d : intent.recipientRef;
+}
+// replay reconstructs the intent, quote, and authorization from the ledger so a
+// corridor can resume without the caller holding them.
+function replay(events) {
+    let intent;
+    let quote;
+    let authorization;
+    for (const e of events) {
+        if (e.intent)
+            intent = e.intent;
+        if (e.quote)
+            quote = e.quote;
+        if (e.authorization)
+            authorization = e.authorization;
+    }
+    if (!intent || !quote || !authorization)
+        return undefined;
+    return { intent, quote, authorization };
+}
+// collectResult returns what the pay-in leg recorded, or an empty result if none
+// is present.
+function collectResult(events) {
+    for (const e of events) {
+        if (e.collect)
+            return e.collect;
+    }
+    return { providerRef: "", received: Money.create("", 0, 0n) };
+}
+function payInRef(events) {
+    return collectResult(events).providerRef;
+}
+// disburseRefs returns the pay-out provider reference and the bridge receipt
+// reference recorded on the disbursing step.
+function disburseRefs(events) {
+    let payOut = "";
+    let bridge = "";
+    for (const e of events) {
+        if (e.state === State.Disbursing) {
+            if (e.settlement)
+                payOut = e.settlement.providerTxRef;
+            if (e.bridge)
+                bridge = e.bridge.receiptRef;
+        }
+    }
+    return { payOut, bridge };
+}
+// lastSettlement returns the settlement recorded on an intent's most recent
+// event, if any, so an idempotent no-op can echo the outcome already reached.
+function lastSettlement(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.settlement)
+            return e.settlement;
+    }
+    return emptySettlement();
+}
+function emptySettlement() {
+    return {
+        intentId: "",
+        state: State.Unspecified,
+        adapterId: "",
+        providerTxRef: "",
+        onchainTxHash: "",
+        receiptHash: new Uint8Array(0),
+        reason: "",
+        settledAt: 0,
+    };
+}
+function reasonOf(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function containsOrEmpty(xs, target) {
+    return xs.length === 0 || xs.includes(target);
+}
+function firstRail(rails) {
+    return rails.length === 0 ? "" : rails[0];
+}
+// submitHash commits to a provider reference so a step carries a payload distinct
+// from every other.
+function submitHash(providerRef) {
+    return hashString(domain("submit"), providerRef);
+}
+function hashString(domainTag, value) {
+    return hashPreimage(new CanonicalWriter().str(domainTag).str(value).preimage());
+}

package/dist/src/compliance.d.ts

@@ -0,0 +1,23 @@
+import type { Money } from "./money.js";
+import type { Quote } from "./message.js";
+export interface KycLimits {
+    perPayment?: Money;
+}
+export interface KycStatus {
+    tier: string;
+    jurisdiction: string;
+    limits: KycLimits;
+}
+export interface KycProvider {
+    status(identity: string): Promise<KycStatus>;
+}
+export declare const permissiveKyc: KycProvider;
+export declare function withinLimits(status: KycStatus, quote: Quote): boolean;
+export interface RiskDecision {
+    allow: boolean;
+    reason: string;
+}
+export interface RiskHook {
+    evaluate(identity: string, intent: import("./message.js").Intent, quote: Quote): RiskDecision;
+}
+export declare const allowRisk: RiskHook;

package/dist/src/compliance.js

@@ -0,0 +1,26 @@
+// permissiveKyc imposes no limits, which is only acceptable for test-mode and
+// testnet adapters.
+export const permissiveKyc = {
+    async status() {
+        return { tier: "unverified", jurisdiction: "", limits: {} };
+    },
+};
+// withinLimits reports whether a quote's source amount is inside an identity's
+// per-payment cap. An absent cap or a currency mismatch is treated as no
+// applicable limit.
+export function withinLimits(status, quote) {
+    const cap = status.limits.perPayment;
+    if (!cap)
+        return true;
+    try {
+        return quote.srcAmount.cmp(cap) <= 0;
+    }
+    catch {
+        return true;
+    }
+}
+export const allowRisk = {
+    evaluate() {
+        return { allow: true, reason: "" };
+    },
+};

package/dist/src/crypto.d.ts

@@ -0,0 +1,12 @@
+import { type KeyObject } from "node:crypto";
+export declare function sha256(data: Uint8Array): Uint8Array;
+export interface Ed25519KeyPair {
+    privateKey: KeyObject;
+    publicKey: Uint8Array;
+}
+export declare function ed25519KeyFromSeed(seed: Uint8Array): Ed25519KeyPair;
+export declare function ed25519Sign(privateKey: KeyObject, message: Uint8Array): Uint8Array;
+export declare function ed25519Verify(publicKeyRaw: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
+export declare function toHex(bytes: Uint8Array): string;
+export declare function fromHex(hex: string): Uint8Array;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;

package/dist/src/crypto.js

@@ -0,0 +1,50 @@
+import { createHash, createPrivateKey, createPublicKey, sign as nodeSign, verify as nodeVerify, } from "node:crypto";
+// SHA-256 of a byte string. Every message hash and receipt commitment flows
+// through it.
+export function sha256(data) {
+    return new Uint8Array(createHash("sha256").update(data).digest());
+}
+// The fixed DER prefixes that wrap a raw 32-byte Ed25519 seed or public key so
+// the platform key APIs will import them. The seed becomes a PKCS8 private key;
+// the public key becomes an SPKI public key.
+const pkcs8SeedPrefix = Buffer.from("302e020100300506032b657004220420", "hex");
+const spkiPublicPrefix = Buffer.from("302a300506032b6570032100", "hex");
+// ed25519KeyFromSeed derives a signing key pair from a 32-byte seed. Ed25519 is
+// deterministic, so a given seed and message always yield the same signature,
+// which is what lets the cross-language vectors pin an exact signature.
+export function ed25519KeyFromSeed(seed) {
+    if (seed.length !== 32) {
+        throw new Error("pact: ed25519 seed must be 32 bytes");
+    }
+    const der = Buffer.concat([pkcs8SeedPrefix, Buffer.from(seed)]);
+    const privateKey = createPrivateKey({ key: der, format: "der", type: "pkcs8" });
+    const spki = createPublicKey(privateKey).export({ format: "der", type: "spki" });
+    return { privateKey, publicKey: new Uint8Array(spki.subarray(spki.length - 32)) };
+}
+export function ed25519Sign(privateKey, message) {
+    return new Uint8Array(nodeSign(null, Buffer.from(message), privateKey));
+}
+export function ed25519Verify(publicKeyRaw, message, signature) {
+    if (publicKeyRaw.length !== 32) {
+        return false;
+    }
+    const spki = Buffer.concat([spkiPublicPrefix, Buffer.from(publicKeyRaw)]);
+    const publicKey = createPublicKey({ key: spki, format: "der", type: "spki" });
+    return nodeVerify(null, Buffer.from(message), publicKey, Buffer.from(signature));
+}
+// toHex and fromHex render byte strings for the wire and for test vectors.
+export function toHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+export function fromHex(hex) {
+    return new Uint8Array(Buffer.from(hex, "hex"));
+}
+export function bytesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}

package/dist/src/fake.d.ts

@@ -0,0 +1,29 @@
+import { RefundKind } from "./adapter.js";
+import type { Money } from "./money.js";
+import type { Quote, Authorization, Settlement } from "./message.js";
+import type { RateSource, EscrowVault } from "./bridge.js";
+import type { PayInLeg, PayOutLeg, PayInCapabilities, PayOutCapabilities, CollectResult, DisburseResult } from "./leg.js";
+export declare class FakeLeg implements PayInLeg, PayOutLeg {
+    readonly id: string;
+    private readonly rail;
+    private readonly currency;
+    private readonly ids;
+    failPayout: boolean;
+    constructor(id: string, rail: string, currency: string, ids: () => string);
+    payInCapabilities(): PayInCapabilities;
+    collect(_intentId: string, quote: Quote, _auth: Authorization, _deliverTo: string): Promise<CollectResult>;
+    refundIn(intentId: string, _kind: RefundKind, reason: string): Promise<Settlement>;
+    payOutCapabilities(): PayOutCapabilities;
+    disburse(_intentId: string, _quote: Quote, _recipientRef: string): Promise<DisburseResult>;
+    reverseOut(intentId: string, reason: string): Promise<Settlement>;
+    private terminal;
+}
+export declare class FakeRates implements RateSource {
+    private readonly table;
+    constructor(table: Record<string, string>);
+    rate(from: string, to: string): Promise<string>;
+}
+export declare class FakeVault implements EscrowVault {
+    hold(intentId: string, _amount: Money): Promise<string>;
+    release(_intentId: string): Promise<void>;
+}