@reinconsole/mock-rails 0.1.0 → 0.2.0

package/README.md

@@ -2,7 +2,7 @@
 
 The simulated payment world for **[Rein](https://github.com/bugiiiii11/rein)** — a fully offline twin of the real [x402](https://www.x402.org) rails. Try the whole guard loop — budgets, caps, kill switch, shadow-spend detection — with no accounts, no chain, no funds.
 
-> **Status: v0.1 — early open-source infrastructure.** APIs may change before 1.0. See it running (the live console world runs on these rails): [Rein console](https://reinconsole-production.up.railway.app/).
+> **Status: v0.2 — early open-source infrastructure.** APIs may change before 1.0. See it running (the live console world runs on these rails): [Rein console](https://app.reinconsole.com).
 
 ## Install
 

package/dist/index.d.ts

@@ -132,8 +132,169 @@ declare const MockPaymentHeader: z.ZodObject<{
     };
 }>;
 type MockPaymentHeader = z.infer<typeof MockPaymentHeader>;
+/**
+ * The v2 envelope (PAYMENT-SIGNATURE header): scheme/network live inside
+ * `accepted` — the requirement the payer chose — around the SAME scheme
+ * payload. `.passthrough()` keeps resource/extensions intact.
+ */
+declare const MockPaymentHeaderV2: z.ZodObject<{
+    x402Version: z.ZodLiteral<2>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    payload: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        /** Atomic-unit amount, mirroring the requirement's maxAmountRequired. */
+        value: z.ZodString;
+        asset: z.ZodString;
+        /**
+         * Rein linkage: the guard's payer stamps the intent id here, the facilitator
+         * memos it onto the ledger entry, and the indexer reconciles exactly. A real
+         * x402 transfer authorization carries a nonce that serves the same role.
+         */
+        intentId: z.ZodOptional<z.ZodString>;
+        nonce: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    x402Version: z.ZodLiteral<2>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    payload: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        /** Atomic-unit amount, mirroring the requirement's maxAmountRequired. */
+        value: z.ZodString;
+        asset: z.ZodString;
+        /**
+         * Rein linkage: the guard's payer stamps the intent id here, the facilitator
+         * memos it onto the ledger entry, and the indexer reconciles exactly. A real
+         * x402 transfer authorization carries a nonce that serves the same role.
+         */
+        intentId: z.ZodOptional<z.ZodString>;
+        nonce: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    x402Version: z.ZodLiteral<2>;
+    accepted: z.ZodObject<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        scheme: z.ZodString;
+        network: z.ZodString;
+        amount: z.ZodString;
+        asset: z.ZodString;
+        payTo: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    payload: z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        /** Atomic-unit amount, mirroring the requirement's maxAmountRequired. */
+        value: z.ZodString;
+        asset: z.ZodString;
+        /**
+         * Rein linkage: the guard's payer stamps the intent id here, the facilitator
+         * memos it onto the ledger entry, and the indexer reconciles exactly. A real
+         * x402 transfer authorization carries a nonce that serves the same role.
+         */
+        intentId: z.ZodOptional<z.ZodString>;
+        nonce: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }, {
+        from: string;
+        to: string;
+        value: string;
+        asset: string;
+        intentId?: string | undefined;
+        nonce?: string | undefined;
+    }>;
+}, z.ZodTypeAny, "passthrough">>;
+type MockPaymentHeaderV2 = z.infer<typeof MockPaymentHeaderV2>;
+/** A payment as the facilitator sees it, whichever dialect it arrived in. */
+interface DecodedPayment {
+    version: 1 | 2;
+    scheme: string;
+    network: string;
+    payload: MockExactPayload;
+}
 declare function encodePaymentHeader(header: MockPaymentHeader): string;
-declare function decodePaymentHeader(raw: string): MockPaymentHeader;
+declare function decodePaymentHeader(raw: string): DecodedPayment;
 /** What the facilitator returns on settle; the vendor base64s it into X-PAYMENT-RESPONSE. */
 declare const SettlementResponse: z.ZodObject<{
     success: z.ZodBoolean;
@@ -188,8 +349,9 @@ declare class MockFacilitator {
      * the plug-in point the real x402 signer replaces.
      */
     payerFor(fromAddress: string): Payer;
-    /** Verify an X-PAYMENT header against the requirement it claims to satisfy. */
-    verify(paymentHeader: string, requirement: PaymentRequirement): MockPaymentHeader;
+    /** Verify a payment header (either dialect) against the requirement it
+     *  claims to satisfy. */
+    verify(paymentHeader: string, requirement: PaymentRequirement): DecodedPayment;
     /**
      * Verify, then settle: write the transfer on the mock chain and return the
      * settlement response the vendor relays via X-PAYMENT-RESPONSE.
@@ -263,6 +425,15 @@ interface MockVendorOptions {
     scheme?: string;
     /** JSON body served once payment settles. */
     body?: unknown;
+    /**
+     * Which x402 dialect the vendor's 402s advertise. 'v1' (default) is the
+     * classic JSON body; 'dual' adds the v2 PAYMENT-REQUIRED header beside it;
+     * 'v2' advertises ONLY the header (the body is not x402) — a strict v2
+     * vendor for proving clients need no v1 fallback. Payments are ACCEPTED in
+     * both dialects (PAYMENT-SIGNATURE or X-PAYMENT) regardless of this option,
+     * mirroring the gate.
+     */
+    advertise?: 'v1' | 'dual' | 'v2';
 }
 interface VendorCall {
     url: string;
@@ -278,10 +449,10 @@ interface MockVendor {
 }
 /**
  * An in-process x402 vendor wired to the mock facilitator: quotes a 402 with
- * payment requirements until the request carries X-PAYMENT, then settles
+ * payment requirements until the request carries a payment, then settles
  * through the facilitator (writing the transfer on the mock ledger) and serves
- * the content with the settlement in X-PAYMENT-RESPONSE. The third leg of the
- * mock rails — guard pays it, indexer watches the ledger behind it.
+ * the content with the settlement in the response headers. The third leg of
+ * the mock rails — guard pays it, indexer watches the ledger behind it.
  */
 declare function createMockVendor(options: MockVendorOptions): MockVendor;
 
@@ -292,4 +463,4 @@ declare class FacilitatorError extends Error {
     constructor(code: FacilitatorErrorCode, message: string);
 }
 
-export { type EngineEvents, FacilitatorError, type FacilitatorErrorCode, type LedgerEntry, MockExactPayload, MockFacilitator, type MockFacilitatorOptions, MockIndexer, type MockIndexerOptions, MockLedger, MockPaymentHeader, type MockVendor, type MockVendorOptions, type SettleResult, SettlementResponse, type ShadowSpend, type TransferInput, type VendorCall, createMockVendor, decodePaymentHeader, encodePaymentHeader, encodeSettlementHeader };
+export { type DecodedPayment, type EngineEvents, FacilitatorError, type FacilitatorErrorCode, type LedgerEntry, MockExactPayload, MockFacilitator, type MockFacilitatorOptions, MockIndexer, type MockIndexerOptions, MockLedger, MockPaymentHeader, MockPaymentHeaderV2, type MockVendor, type MockVendorOptions, type SettleResult, SettlementResponse, type ShadowSpend, type TransferInput, type VendorCall, createMockVendor, decodePaymentHeader, encodePaymentHeader, encodeSettlementHeader };