@myzonerocks/pact 0.1.0

package/dist/test/paypal.test.js

@@ -0,0 +1,140 @@
+import { describe, it, expect } from "vitest";
+import { Client } from "../src/client.js";
+import { Money } from "../src/money.js";
+import { State } from "../src/state.js";
+import { isDirect } from "../src/message.js";
+import { RefundKind } from "../src/adapter.js";
+import { Ed25519Signer, Ed25519Verifier } from "../src/signing.js";
+import { fromHex } from "../src/crypto.js";
+import { PaypalLeg, ErrSignatureMismatch, majorAmount, } from "../src/adapters/paypal.js";
+function counter(prefix) {
+    let n = 0;
+    return () => `${prefix}${String(++n).padStart(3, "0")}`;
+}
+function signerVerifier(identity) {
+    const seed = fromHex("00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff");
+    const signer = Ed25519Signer.fromSeed(identity, seed);
+    return { signer, verifier: new Ed25519Verifier(new Map([[identity, signer.publicKey]])) };
+}
+// FakePaypal is an in-memory stand-in for PayPal so the leg runs end to end with
+// no network and no credentials. verify controls whether an inbound webhook is
+// treated as authentic.
+class FakePaypal {
+    verify = true;
+    lastOrder;
+    lastPayout;
+    lastRefund;
+    ids;
+    constructor(ids) {
+        this.ids = ids;
+    }
+    async createAndCaptureOrder(params) {
+        this.lastOrder = params;
+        const id = this.ids();
+        return { orderId: `order_${id}`, captureId: `capture_${id}`, status: "COMPLETED" };
+    }
+    async sendPayout(params) {
+        this.lastPayout = params;
+        return { batchId: `batch_${this.ids()}`, status: "PENDING" };
+    }
+    async refundCapture(params) {
+        this.lastRefund = params;
+        return { id: `refund_${this.ids()}`, status: "COMPLETED" };
+    }
+    async verifyWebhook() {
+        return this.verify;
+    }
+}
+function buildLeg(api) {
+    return new PaypalLeg({ currencies: ["USD"], api, ids: counter("pp") });
+}
+function quote(fields) {
+    return {
+        id: "q",
+        intentId: "intent-1",
+        payInAdapterId: "paypal",
+        payInRail: "paypal",
+        payOutAdapterId: "paypal",
+        payOutRail: "paypal",
+        bridgeId: "passthrough",
+        srcAmount: Money.parse("USD", 2, "0"),
+        dstAmount: Money.parse("USD", 2, "0"),
+        fees: Money.parse("USD", 2, "0"),
+        fxRate: "1",
+        expiresAt: 0,
+        providerQuoteRef: "",
+        latencyEstimateMs: 0,
+        ...fields,
+    };
+}
+describe("paypal major amount", () => {
+    it("renders minor units as the decimal-major string PayPal expects", () => {
+        expect(majorAmount("1500", 2)).toBe("15.00");
+        expect(majorAmount("5", 2)).toBe("0.05");
+        expect(majorAmount("1290", 0)).toBe("1290");
+        expect(majorAmount("100", 2)).toBe("1.00");
+    });
+});
+describe("paypal webhook verification", () => {
+    it("maps an authentic capture to a settled event and rejects an unverifiable one", async () => {
+        const api = new FakePaypal(counter("tx"));
+        const leg = buildLeg(api);
+        const payload = new TextEncoder().encode(`{"event_type":"PAYMENT.CAPTURE.COMPLETED","resource":{"id":"capture_1","custom_id":"pact:intent-1"}}`);
+        const events = await leg.parseWebhook(payload, { "PayPal-Transmission-Id": ["t1"] });
+        expect(events).toHaveLength(1);
+        expect(events[0].state).toBe(State.Settled);
+        expect(events[0].intentId).toBe("intent-1");
+        expect(events[0].providerTxRef).toBe("capture_1");
+        // PayPal reports the signature does not verify, so the payload is rejected.
+        api.verify = false;
+        await expect(leg.parseWebhook(payload, {})).rejects.toThrow(ErrSignatureMismatch);
+    });
+});
+describe("paypal direct corridor", () => {
+    const now = 1_700_000_000_000;
+    it("charges the recipient payee in one phase and refunds fully", async () => {
+        const { signer, verifier } = signerVerifier("alice");
+        const api = new FakePaypal(counter("tx"));
+        const leg = buildLeg(api);
+        const client = new Client({
+            payIn: [leg],
+            payOut: [leg],
+            verifier,
+            clock: () => now,
+            idGen: counter("intent"),
+        });
+        const intent = client.createIntent({
+            senderRef: "alice",
+            recipientRef: "merchant@example.com",
+            amount: Money.parse("USD", 2, "1500"),
+            expiresAt: now + 600_000,
+            allowedRails: ["paypal"],
+        });
+        const quotes = await client.quoteOptions(intent, [{ payInAdapterId: leg.id, currency: "USD", exponent: 2 }]);
+        const chosen = await client.select(quotes, signer.identity());
+        expect(isDirect(chosen)).toBe(true);
+        const auth = await client.authorize(intent, chosen, signer);
+        await client.initiate(intent, chosen, auth);
+        const { settlement } = await client.advance(intent.id, leg.id, { intentId: intent.id, state: State.Settled, providerTxRef: "", onchainTxHash: "", reason: "", settledAt: 0 });
+        expect(settlement.state).toBe(State.Settled);
+        // The order was created to the recipient payee for the gross amount.
+        expect(api.lastOrder.payee).toBe("merchant@example.com");
+        expect(api.lastOrder.value).toBe("15.00");
+        // A full refund is accepted and binds to the capture id; a partial refund is a
+        // shape PayPal does not express here.
+        await leg.refundIn(intent.id, RefundKind.Full, "changed mind");
+        expect(api.lastRefund.captureId).toBe(settlement.providerTxRef);
+        await expect(leg.refundIn(intent.id, RefundKind.Partial, "half")).rejects.toThrow();
+    });
+});
+describe("paypal pay-out", () => {
+    it("sends the recipient's amount and refuses a reversal", async () => {
+        const api = new FakePaypal(counter("tx"));
+        const leg = buildLeg(api);
+        const result = await leg.disburse("intent-1", quote({ dstAmount: Money.parse("USD", 2, "1290") }), "receiver@example.com");
+        expect(result.providerRef).not.toBe("");
+        expect(api.lastPayout.receiver).toBe("receiver@example.com");
+        expect(api.lastPayout.value).toBe("12.90");
+        await expect(leg.reverseOut("intent-1", "oops")).rejects.toThrow();
+    });
+});

package/dist/test/policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/policy.test.js

@@ -0,0 +1,131 @@
+import { describe, it, expect } from "vitest";
+import { Client } from "../src/client.js";
+import { Money } from "../src/money.js";
+import { FakeLeg } from "../src/fake.js";
+import { Ed25519Signer, Ed25519Verifier } from "../src/signing.js";
+import { fromHex } from "../src/crypto.js";
+import { Erc20Leg } from "../src/adapters/erc20.js";
+import { TieredKyc, WindowRisk } from "../src/policy.js";
+function counter() {
+    let n = 0;
+    return () => `id-${String(++n).padStart(3, "0")}`;
+}
+function signerVerifier(identity) {
+    const seed = fromHex("00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff");
+    const signer = Ed25519Signer.fromSeed(identity, seed);
+    return { signer, verifier: new Ed25519Verifier(new Map([[identity, signer.publicKey]])) };
+}
+function tiers() {
+    const basic = {
+        name: "basic",
+        jurisdiction: "US",
+        perPayment: Money.parse("USD", 2, "5000"),
+        windowSpend: Money.parse("USD", 2, "8000"),
+        allowedRails: ["card"],
+    };
+    const unverified = { name: "unverified", jurisdiction: "", allowedRails: ["card"] };
+    return new TieredKyc([basic, unverified], { alice: "basic" }, unverified);
+}
+class OkChain {
+    async send(_call) {
+        return "0xtx";
+    }
+    async receipt() {
+        return { status: "success", blockTimestampMs: 0 };
+    }
+}
+const now = 1_700_000_000_000;
+const cardFunding = [{ payInAdapterId: "card", currency: "USD", exponent: 2 }];
+describe("tiered kyc and window risk policy", () => {
+    it("filters a quote over the tier's per-payment cap through the router", async () => {
+        const { signer, verifier } = signerVerifier("alice");
+        const card = new FakeLeg("card", "card", "USD", counter());
+        const client = new Client({
+            payIn: [card],
+            payOut: [card],
+            verifier,
+            kyc: tiers(),
+            clock: () => now,
+            idGen: counter(),
+        });
+        const over = client.createIntent({
+            senderRef: "alice",
+            recipientRef: "bob",
+            amount: Money.parse("USD", 2, "6000"),
+            expiresAt: now + 60_000,
+            allowedRails: ["card"],
+        });
+        await expect(client.select(await client.quoteOptions(over, cardFunding), signer.identity())).rejects.toThrow();
+        const within = client.createIntent({
+            senderRef: "alice",
+            recipientRef: "bob",
+            amount: Money.parse("USD", 2, "4000"),
+            expiresAt: now + 60_000,
+            allowedRails: ["card"],
+        });
+        await expect(client.select(await client.quoteOptions(within, cardFunding), signer.identity())).resolves.toBeDefined();
+    });
+    it("vetoes a rail the tier does not permit", async () => {
+        const { signer, verifier } = signerVerifier("alice");
+        const kyc = tiers();
+        const risk = new WindowRisk(kyc, 3_600_000, () => now);
+        const leg = new Erc20Leg({
+            token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+            currency: "USD",
+            chain: new OkChain(),
+            ids: counter(),
+        });
+        const client = new Client({
+            payIn: [leg],
+            payOut: [leg],
+            verifier,
+            kyc,
+            risk,
+            clock: () => now,
+            idGen: counter(),
+        });
+        const intent = client.createIntent({
+            senderRef: "alice",
+            recipientRef: "bob",
+            amount: Money.parse("USD", 2, "1000"),
+            expiresAt: now + 60_000,
+            allowedRails: ["erc20"],
+            metadata: { recipient_destination: "0x00000000000000000000000000000000000000aa" },
+        });
+        const quotes = await client.quoteOptions(intent, [{ payInAdapterId: "erc20", currency: "USD", exponent: 2 }]);
+        const quote = await client.select(quotes, signer.identity());
+        await expect(client.authorize(intent, quote, signer)).rejects.toThrow();
+    });
+    it("blocks overspend across the rolling window and releases it after the window elapses", async () => {
+        const { signer, verifier } = signerVerifier("alice");
+        const kyc = tiers();
+        let clockMs = now;
+        const risk = new WindowRisk(kyc, 3_600_000, () => clockMs);
+        const card = new FakeLeg("card", "card", "USD", counter());
+        const client = new Client({
+            payIn: [card],
+            payOut: [card],
+            verifier,
+            kyc,
+            risk,
+            clock: () => clockMs,
+            idGen: counter(),
+        });
+        const pay = async (minor) => {
+            const intent = client.createIntent({
+                senderRef: "alice",
+                recipientRef: "bob",
+                amount: Money.parse("USD", 2, minor),
+                expiresAt: clockMs + 60_000,
+                allowedRails: ["card"],
+            });
+            const quote = await client.select(await client.quoteOptions(intent, cardFunding), signer.identity());
+            await client.authorize(intent, quote, signer);
+        };
+        await pay("4000");
+        await pay("4000");
+        await expect(pay("4000")).rejects.toThrow();
+        clockMs = now + 3_600_000 + 1;
+        await expect(pay("4000")).resolves.toBeUndefined();
+    });
+});

package/dist/test/stripe.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/stripe.test.js

@@ -0,0 +1,176 @@
+import { describe, it, expect } from "vitest";
+import { createHmac } from "node:crypto";
+import { Client } from "../src/client.js";
+import { Money } from "../src/money.js";
+import { State } from "../src/state.js";
+import { isDirect } from "../src/message.js";
+import { RefundKind } from "../src/adapter.js";
+import { Ed25519Signer, Ed25519Verifier } from "../src/signing.js";
+import { fromHex } from "../src/crypto.js";
+import { StripeLeg, ErrNoSignature, ErrSignatureMismatch, ErrTimestampOutOfTolerance, } from "../src/adapters/stripe.js";
+function counter() {
+    let n = 0;
+    return () => `pi_test_${String(++n).padStart(3, "0")}`;
+}
+function signerVerifier(identity) {
+    const seed = fromHex("00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff");
+    const signer = Ed25519Signer.fromSeed(identity, seed);
+    return { signer, verifier: new Ed25519Verifier(new Map([[identity, signer.publicKey]])) };
+}
+// FakeStripe is an in-memory stand-in for Stripe so the leg can be exercised end
+// to end without a network or credentials.
+class FakeStripe {
+    intents = new Map();
+    ids;
+    constructor(ids) {
+        this.ids = ids;
+    }
+    async createPaymentIntent(params, _idempotencyKey) {
+        const pi = {
+            id: this.ids(),
+            status: "requires_capture",
+            amount: params.amount,
+            currency: params.currency,
+            latestCharge: "",
+            metadata: params.metadata,
+            created: 1_700_000_000,
+        };
+        this.intents.set(pi.id, pi);
+        return pi;
+    }
+    async capturePaymentIntent(id, _idempotencyKey) {
+        const pi = this.intents.get(id);
+        pi.status = "succeeded";
+        this.intents.set(id, pi);
+        return pi;
+    }
+    async findPaymentIntent(pactIntentId) {
+        for (const pi of this.intents.values()) {
+            if (pi.metadata["pact_intent_id"] === pactIntentId) {
+                return pi;
+            }
+        }
+        throw new Error(`stripe: no payment intent for ${pactIntentId}`);
+    }
+    async createRefund(params, _idempotencyKey) {
+        return { id: this.ids(), status: "succeeded", amount: params.amount };
+    }
+}
+// cardPayout is a minimal pay-out leg for the direct corridor. Stripe collects to
+// the recipient's account inside collect, so the pay-out side is a no-op that only
+// lets the client compose a same-provider direct corridor.
+class CardPayout {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+    payOutCapabilities() {
+        return { rails: ["card"], currencies: ["USD"], reversible: false };
+    }
+    async disburse() {
+        return { providerRef: "" };
+    }
+    async reverseOut(intentId, reason) {
+        return {
+            intentId,
+            state: State.Refunded,
+            adapterId: this.id,
+            providerTxRef: "",
+            onchainTxHash: "",
+            receiptHash: new Uint8Array(0),
+            reason,
+            settledAt: 0,
+        };
+    }
+}
+const webhookSecret = "whsec_test_secret";
+const clockSeconds = 1_700_000_000;
+function buildLeg(api) {
+    return new StripeLeg({
+        currencies: ["USD"],
+        api,
+        webhookKey: webhookSecret,
+        clock: () => clockSeconds,
+        ids: counter(),
+    });
+}
+function signHeader(payload, secret, timestamp) {
+    const mac = createHmac("sha256", secret);
+    mac.update(String(timestamp));
+    mac.update(".");
+    mac.update(payload);
+    return `t=${timestamp},v1=${mac.digest("hex")}`;
+}
+function succeededPayload(piId, intentId) {
+    const json = `{"type":"payment_intent.succeeded","data":{"object":{"id":${JSON.stringify(piId)},"status":"succeeded","metadata":{"pact_intent_id":${JSON.stringify(intentId)}},"created":${clockSeconds}}}}`;
+    return new TextEncoder().encode(json);
+}
+describe("stripe webhook verification", () => {
+    it("verifies a valid signature and rejects a tampered, stale, or missing one", () => {
+        const leg = buildLeg(new FakeStripe(counter()));
+        const payload = succeededPayload("pi_1", "intent-1");
+        const header = signHeader(payload, webhookSecret, clockSeconds);
+        const events = leg.parseWebhook(payload, { "Stripe-Signature": [header] });
+        expect(events).toHaveLength(1);
+        expect(events[0].state).toBe(State.Settled);
+        expect(events[0].intentId).toBe("intent-1");
+        expect(events[0].providerTxRef).toBe("pi_1");
+        // A tampered body no longer matches the signature.
+        const tampered = Uint8Array.from(payload);
+        const last = tampered.length - 3;
+        tampered[last] = tampered[last] ^ 0xff;
+        expect(() => leg.parseWebhook(tampered, { "Stripe-Signature": [header] })).toThrow(ErrSignatureMismatch);
+        // A stale timestamp is rejected as a possible replay.
+        const old = signHeader(payload, webhookSecret, clockSeconds - 4000);
+        expect(() => leg.parseWebhook(payload, { "Stripe-Signature": [old] })).toThrow(ErrTimestampOutOfTolerance);
+        // A missing signature header is rejected outright.
+        expect(() => leg.parseWebhook(payload, {})).toThrow(ErrNoSignature);
+    });
+});
+describe("stripe webhook failure mapping", () => {
+    it("maps payment_intent.payment_failed to a failed event", () => {
+        const leg = buildLeg(new FakeStripe(counter()));
+        const json = `{"type":"payment_intent.payment_failed","data":{"object":{"id":"pi_x","metadata":{"pact_intent_id":"intent-9"},"created":${clockSeconds}}}}`;
+        const payload = new TextEncoder().encode(json);
+        const header = signHeader(payload, webhookSecret, clockSeconds);
+        const events = leg.parseWebhook(payload, { "Stripe-Signature": [header] });
+        expect(events).toHaveLength(1);
+        expect(events[0].state).toBe(State.Failed);
+    });
+});
+describe("stripe direct card corridor", () => {
+    const now = 1_700_000_000_000;
+    it("collects to the recipient in one phase and refunds fully", async () => {
+        const { signer, verifier } = signerVerifier("alice");
+        const api = new FakeStripe(counter());
+        const leg = buildLeg(api);
+        const client = new Client({
+            payIn: [leg],
+            payOut: [new CardPayout(leg.id)],
+            verifier,
+            clock: () => now,
+            idGen: counter(),
+        });
+        const intent = client.createIntent({
+            senderRef: "alice",
+            recipientRef: "acct_merchant",
+            amount: Money.parse("USD", 2, "1500"),
+            expiresAt: now + 600_000,
+            allowedRails: ["card"],
+        });
+        const quotes = await client.quoteOptions(intent, [{ payInAdapterId: leg.id, currency: "USD", exponent: 2 }]);
+        const quote = await client.select(quotes, signer.identity());
+        expect(isDirect(quote)).toBe(true);
+        const auth = await client.authorize(intent, quote, signer);
+        await client.initiate(intent, quote, auth);
+        await client.advance(intent.id, leg.id, { intentId: intent.id, state: State.Settled, providerTxRef: "", onchainTxHash: "", reason: "", settledAt: 0 });
+        expect(client.state(intent.id)).toBe(State.Settled);
+        // The captured intent carries the pact intent id and reached a captured status.
+        const pi = await api.findPaymentIntent(intent.id);
+        expect(pi.status).toBe("succeeded");
+        // Stripe supports partial reversal, so a full refund is accepted and a
+        // counter-transfer is a shape the card rail does not express.
+        await leg.refundIn(intent.id, RefundKind.Full, "changed mind");
+        await expect(leg.refundIn(intent.id, RefundKind.CounterTransfer, "wrong kind")).rejects.toThrow();
+    });
+});

package/dist/test/vectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/vectors.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { Money } from "../src/money.js";
+import { stateName } from "../src/state.js";
+import { intentPreimage, intentHash, quotePreimage, quoteHash, signingPreimage, authorizationHash, receiptHash, } from "../src/message.js";
+import { eventReceipt, chainLeaf } from "../src/ledger.js";
+import { Ed25519Signer, Ed25519Verifier } from "../src/signing.js";
+import { toHex, fromHex } from "../src/crypto.js";
+const here = dirname(fileURLToPath(import.meta.url));
+const vectors = JSON.parse(readFileSync(join(here, "..", "..", "..", "spec", "test-vectors.json"), "utf8"));
+function money(m) {
+    return Money.parse(m.currency, m.exponent, m.amount);
+}
+function intentFrom(j) {
+    return {
+        id: j.id,
+        senderRef: j.sender_ref,
+        recipientRef: j.recipient_ref,
+        amount: money(j.amount),
+        memo: j.memo,
+        expiresAt: j.expires_at,
+        allowedRails: j.allowed_rails,
+        metadata: j.metadata,
+    };
+}
+function quoteFrom(j) {
+    return {
+        id: j.id,
+        intentId: j.intent_id,
+        payInAdapterId: j.pay_in_adapter_id,
+        payInRail: j.pay_in_rail,
+        payOutAdapterId: j.pay_out_adapter_id,
+        payOutRail: j.pay_out_rail,
+        bridgeId: j.bridge_id,
+        srcAmount: money(j.src_amount),
+        dstAmount: money(j.dst_amount),
+        fees: money(j.fees),
+        fxRate: j.fx_rate,
+        expiresAt: j.expires_at,
+        providerQuoteRef: j.provider_quote_ref,
+        latencyEstimateMs: j.latency_estimate_ms,
+    };
+}
+const nameToState = Object.fromEntries(Object.entries(stateName).map(([s, name]) => [name, Number(s)]));
+describe("shared conformance vectors", () => {
+    it("reproduces every intent preimage and hash", () => {
+        for (const entry of vectors.intents) {
+            const intent = intentFrom(entry.intent);
+            expect(toHex(intentPreimage(intent))).toBe(entry.preimage_hex);
+            expect(toHex(intentHash(intent))).toBe(entry.hash_hex);
+        }
+    });
+    it("reproduces the quote preimage and hash", () => {
+        const quote = quoteFrom(vectors.quote.quote);
+        expect(toHex(quotePreimage(quote))).toBe(vectors.quote.preimage_hex);
+        expect(toHex(quoteHash(quote))).toBe(vectors.quote.hash_hex);
+    });
+    it("reproduces the authorization preimage, hash, and Ed25519 signature", () => {
+        const a = vectors.authorization;
+        const intentHashBytes = fromHex(a.intent_hash_hex);
+        const quoteHashBytes = fromHex(a.quote_hash_hex);
+        const preimage = signingPreimage(intentHashBytes, quoteHashBytes, a.signer_identity, a.signed_at);
+        expect(toHex(preimage)).toBe(a.signing_preimage_hex);
+        expect(toHex(authorizationHash(intentHashBytes, quoteHashBytes, a.signer_identity, a.signed_at))).toBe(a.auth_hash_hex);
+        const seed = fromHex(vectors.ed25519.seed_hex);
+        const signer = Ed25519Signer.fromSeed(a.signer_identity, seed);
+        expect(toHex(signer.publicKey)).toBe(vectors.ed25519.public_key_hex);
+        const signature = signer.sign(preimage);
+        expect(toHex(signature)).toBe(a.signature_hex);
+        const verifier = new Ed25519Verifier(new Map([[a.signer_identity, signer.publicKey]]));
+        expect(verifier.verify(a.signer_identity, preimage, signature)).toBe(true);
+    });
+    it("reproduces the settlement receipt hash", () => {
+        const r = vectors.receipt;
+        const hash = receiptHash(fromHex(r.auth_hash_hex), r.provider_tx_ref, nameToState[r.state]);
+        expect(toHex(hash)).toBe(r.receipt_hash_hex);
+    });
+    it("reproduces every ledger leaf and the Merkle head", () => {
+        const l = vectors.ledger;
+        let prevLeaf = new Uint8Array(32);
+        l.steps.forEach((step, i) => {
+            const receipt = eventReceipt(i + 1, l.intent_id, nameToState[step.state], fromHex(step.payload_hash_hex));
+            const leaf = chainLeaf(prevLeaf, receipt);
+            expect(toHex(leaf)).toBe(step.leaf_hex);
+            prevLeaf = leaf;
+        });
+        expect(toHex(prevLeaf)).toBe(l.head_hex);
+    });
+});

package/dist/test/wire.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/wire.test.js

@@ -0,0 +1,104 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { Money } from "../src/money.js";
+import { State, stateName } from "../src/state.js";
+import { WireKind, encodeIntent, encodeQuote, encodeAuthorization, encodeSettlement, encodeMessage, decodeMessage, decodeIntent, decodeQuote, decodeAuthorization, decodeSettlement, } from "../src/wire.js";
+import { toHex, fromHex } from "../src/crypto.js";
+const here = dirname(fileURLToPath(import.meta.url));
+const vectors = JSON.parse(readFileSync(join(here, "..", "..", "..", "spec", "test-vectors.json"), "utf8"));
+const nameToState = Object.fromEntries(Object.entries(stateName).map(([s, name]) => [name, Number(s)]));
+function money(m) {
+    return Money.parse(m.currency, m.exponent, m.amount);
+}
+function intentFrom(j) {
+    return {
+        id: j.id,
+        senderRef: j.sender_ref,
+        recipientRef: j.recipient_ref,
+        amount: money(j.amount),
+        memo: j.memo,
+        expiresAt: j.expires_at,
+        allowedRails: j.allowed_rails,
+        metadata: j.metadata,
+    };
+}
+function quoteFrom(j) {
+    return {
+        id: j.id,
+        intentId: j.intent_id,
+        payInAdapterId: j.pay_in_adapter_id,
+        payInRail: j.pay_in_rail,
+        payOutAdapterId: j.pay_out_adapter_id,
+        payOutRail: j.pay_out_rail,
+        bridgeId: j.bridge_id,
+        srcAmount: money(j.src_amount),
+        dstAmount: money(j.dst_amount),
+        fees: money(j.fees),
+        fxRate: j.fx_rate,
+        expiresAt: j.expires_at,
+        providerQuoteRef: j.provider_quote_ref,
+        latencyEstimateMs: j.latency_estimate_ms,
+    };
+}
+describe("wire codec conformance and round-trips", () => {
+    it("encodes and decodes an intent to the vector bytes", () => {
+        const intent = intentFrom(vectors.intents[0].intent);
+        expect(toHex(encodeIntent(intent))).toBe(vectors.wire.intent_hex);
+        const decoded = decodeIntent(fromHex(vectors.wire.intent_hex));
+        expect(decoded.id).toBe(intent.id);
+        expect(decoded.amount.minor()).toBe(intent.amount.minor());
+        expect(decoded.allowedRails).toEqual(intent.allowedRails);
+        expect(decoded.metadata).toEqual(intent.metadata);
+    });
+    it("encodes and decodes a quote to the vector bytes", () => {
+        const quote = quoteFrom(vectors.quote.quote);
+        expect(toHex(encodeQuote(quote))).toBe(vectors.wire.quote_hex);
+        const decoded = decodeQuote(fromHex(vectors.wire.quote_hex));
+        expect(decoded.srcAmount.minor()).toBe(quote.srcAmount.minor());
+        expect(decoded.latencyEstimateMs).toBe(quote.latencyEstimateMs);
+    });
+    it("encodes and decodes an authorization to the vector bytes", () => {
+        const w = vectors.wire.authorization;
+        const auth = {
+            intentId: w.intent_id,
+            quoteId: w.quote_id,
+            signerIdentity: w.signer_identity,
+            signedAt: w.signed_at,
+            signature: fromHex(w.signature_hex),
+        };
+        expect(toHex(encodeAuthorization(auth))).toBe(w.hex);
+        const decoded = decodeAuthorization(fromHex(w.hex));
+        expect(decoded.signerIdentity).toBe(auth.signerIdentity);
+        expect(toHex(decoded.signature)).toBe(w.signature_hex);
+    });
+    it("encodes and decodes a settlement to the vector bytes", () => {
+        const w = vectors.wire.settlement;
+        const settlement = {
+            intentId: w.intent_id,
+            state: nameToState[w.state],
+            adapterId: w.adapter_id,
+            providerTxRef: w.provider_tx_ref,
+            onchainTxHash: w.onchain_tx_hash,
+            receiptHash: fromHex(w.receipt_hash_hex),
+            reason: w.reason,
+            settledAt: w.settled_at,
+        };
+        expect(toHex(encodeSettlement(settlement))).toBe(w.hex);
+        const decoded = decodeSettlement(fromHex(w.hex));
+        expect(decoded.state).toBe(State.Settled);
+        expect(toHex(decoded.receiptHash)).toBe(w.receipt_hash_hex);
+    });
+    it("dispatches a tagged frame back to its type", () => {
+        const intent = intentFrom(vectors.intents[0].intent);
+        const frame = encodeMessage({ kind: WireKind.Intent, message: intent });
+        const decoded = decodeMessage(frame);
+        expect(decoded.kind).toBe(WireKind.Intent);
+        expect(decoded.message.id).toBe(intent.id);
+    });
+    it("rejects a truncated frame", () => {
+        const full = encodeIntent(intentFrom(vectors.intents[0].intent));
+        expect(() => decodeIntent(full.subarray(0, full.length - 3))).toThrow();
+    });
+});