@myzonerocks/pact 0.1.3 → 0.1.4

package/src/wire.ts

@@ -1,5 +1,5 @@
 import { Money } from "./money.js";
-import { State } from "./state.js";
+import { State, stateName } from "./state.js";
 import { CanonicalWriter } from "./canonical.js";
 import type { Intent, Quote, Authorization, Settlement } from "./message.js";
 
@@ -146,7 +146,14 @@ class WireReader {
     }
     const view = new DataView(this.buf.buffer, this.buf.byteOffset + this.pos, 8);
     this.pos += 8;
-    return Number(view.getBigUint64(0, false));
+    const value = view.getBigUint64(0, false);
+    // A value above 2^53 cannot be held exactly in a JS number, so reject it
+    // rather than decode a Go or Dart value into a silently different one. Every
+    // real field here — millisecond timestamps, ordinals, latency — fits easily.
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error("pact: u64 field exceeds the exact-integer range");
+    }
+    return Number(value);
   }
 
   money(): Money {
@@ -231,11 +238,21 @@ export function decodeAuthorization(b: Uint8Array): Authorization {
   return auth;
 }
 
+// stateFromOrdinal rejects an ordinal outside the known states rather than pass
+// an out-of-range number through as a State, so a corrupt wire byte cannot decode
+// to a nonexistent state.
+function stateFromOrdinal(n: number): State {
+  if (!(n in stateName)) {
+    throw new Error(`pact: unknown settlement state ordinal ${n}`);
+  }
+  return n as State;
+}
+
 export function decodeSettlement(b: Uint8Array): Settlement {
   const r = new WireReader(b);
   const settlement: Settlement = {
     intentId: r.str(),
-    state: r.u64() as State,
+    state: stateFromOrdinal(r.u64()),
     adapterId: r.str(),
     providerTxRef: r.str(),
     onchainTxHash: r.str(),

package/src/fake.ts

@@ -1,96 +0,0 @@
-import { State } from "./state.js";
-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";
-
-// FakeLeg is a deterministic, in-memory pay-in and pay-out leg. It settles
-// instantly with no network and implements both sides so a test can build a
-// direct corridor from one leg or a bridged corridor from two. failPayout makes
-// its disburse fail so a test can exercise the escrow-unwind path.
-export class FakeLeg implements PayInLeg, PayOutLeg {
-  failPayout = false;
-
-  constructor(
-    readonly id: string,
-    private readonly rail: string,
-    private readonly currency: string,
-    private readonly ids: () => string,
-  ) {}
-
-  payInCapabilities(): PayInCapabilities {
-    return { rails: [this.rail], currencies: [this.currency], refunds: RefundKind.Full };
-  }
-
-  // collect takes the payer's funds. received is the net the bridge converts —
-  // the source the payer paid less the corridor fees.
-  async collect(_intentId: string, quote: Quote, _auth: Authorization, _deliverTo: string): Promise<CollectResult> {
-    return { providerRef: this.ids(), received: quote.srcAmount.sub(quote.fees) };
-  }
-
-  async refundIn(intentId: string, _kind: RefundKind, reason: string): Promise<Settlement> {
-    return this.terminal(intentId, reason);
-  }
-
-  payOutCapabilities(): PayOutCapabilities {
-    return { rails: [this.rail], currencies: [this.currency], reversible: false };
-  }
-
-  async disburse(_intentId: string, _quote: Quote, _recipientRef: string): Promise<DisburseResult> {
-    if (this.failPayout) {
-      throw new Error("fake: payout failed");
-    }
-    return { providerRef: this.ids() };
-  }
-
-  async reverseOut(intentId: string, reason: string): Promise<Settlement> {
-    return this.terminal(intentId, reason);
-  }
-
-  private terminal(intentId: string, reason: string): Settlement {
-    return {
-      intentId,
-      state: State.Refunded,
-      adapterId: this.id,
-      providerTxRef: this.ids(),
-      onchainTxHash: "",
-      receiptHash: new Uint8Array(0),
-      reason,
-      settledAt: 0,
-    };
-  }
-}
-
-// FakeRates is an in-memory rate source keyed by "FROM:TO", standing in for a
-// price feed so a bridge can be tested without a live market.
-export class FakeRates implements RateSource {
-  constructor(private readonly table: Record<string, string>) {}
-
-  async rate(from: string, to: string): Promise<string> {
-    const rate = this.table[`${from}:${to}`];
-    if (rate === undefined) {
-      throw new Error(`fake: no rate for ${from}:${to}`);
-    }
-    return rate;
-  }
-}
-
-// FakeVault is an in-memory escrow that records holds and releases, standing in
-// for the custody a real bridge relies on.
-export class FakeVault implements EscrowVault {
-  async hold(intentId: string, _amount: Money): Promise<string> {
-    return `escrow-${intentId}`;
-  }
-
-  async release(_intentId: string): Promise<void> {
-    // Nothing to release in memory.
-  }
-}