@toon-protocol/sdk 2.1.0 → 2.2.0

package/dist/{swap-Oub-0vqU.d.ts → swap-PFQTJZA7.d.ts}

@@ -162,6 +162,273 @@ declare function encryptFulfillClaim(params: EncryptFulfillClaimParams): Encrypt
  */
 declare function decryptFulfillClaim(params: DecryptFulfillClaimParams): Uint8Array;
 
+/**
+ * rfc-0039-style stream receipts (issue #84, rolling-swap spec §7.2).
+ *
+ * Per fulfilled packet the maker attaches a compact SIGNED receipt to the
+ * FULFILL accept-metadata: a monotone cumulative proof of asset-B delivered
+ * in the session. The receipt chain is the sender's portable audit/dispute
+ * artifact today (it makes the maker-debt bound provable to a third party)
+ * and the natural input to a future escrow layer. Receipts are
+ * session-scoped via `streamNonce`; the latest receipt supersedes all
+ * earlier ones, mirroring the highest-nonce rule for claims.
+ *
+ * ## Deviations from Interledger rfc-0039 (documented per spec §7.2 — the
+ * TOON-native equivalent deliberately does not import the STREAM framing):
+ *
+ * - **Signature, not HMAC.** rfc-0039 authenticates receipts with
+ *   HMAC-SHA256 over a pre-shared 32-byte Receipt Secret, so only a party
+ *   holding the secret can verify. TOON receipts are BIP-340 Schnorr
+ *   signatures by the maker's receipt key (default: the maker's Nostr
+ *   identity key — the same `swapPubkey` the sender already discovered via
+ *   kind:10032), making every receipt verifiable by ANY third party with
+ *   the maker's pubkey. No Receipt Secret exists or is provisioned.
+ * - **Nonce provisioning.** rfc-0039's Verifier generates the Receipt Nonce
+ *   and communicates it out-of-band (SPSP headers). Here the sender (who is
+ *   its own verifier today) generates a 16-byte `streamNonce` per
+ *   `streamSwap()` invocation and communicates it in-band as the rumor's
+ *   `stream-nonce` tag. Legacy makers ignore the unknown tag.
+ * - **Encoding.** JSON object inside the accept-metadata dict rather than a
+ *   CANONICAL-OER STREAM frame. A deterministic length-prefixed binary
+ *   encoding ({@link encodeReceiptSigningPayload}) is used ONLY as the
+ *   signing preimage.
+ * - **Fields.** `seq` (maker's per-session fulfill counter — enables hole
+ *   detection, absent from rfc-0039), `rate` + `rateTimestamp` (the quote
+ *   tape entry, attested under the maker signature) are added; the STREAM
+ *   `Stream ID` is dropped (one logical stream per session — the
+ *   `streamNonce` IS the stream identity); `Total Received` is a decimal
+ *   string (bigint range) rather than UInt64.
+ *
+ * rfc-0039 semantics preserved: one receipt per fulfilled packet, each
+ * carrying a progressively higher cumulative total; latest supersedes;
+ * verification = authenticity check + monotonicity against previously seen
+ * receipts for the same nonce.
+ *
+ * @module
+ */
+/** Wire version of the TOON stream receipt. */
+declare const STREAM_RECEIPT_VERSION: 1;
+/** Domain-separation tag prefixed to the receipt signing payload. */
+declare const STREAM_RECEIPT_SIGNING_TAG = "toon.stream-receipt.v1";
+/** The signed fields of a {@link StreamReceipt} (everything except `sig`). */
+interface StreamReceiptFields {
+    /** Receipt wire version — always {@link STREAM_RECEIPT_VERSION}. */
+    v: typeof STREAM_RECEIPT_VERSION;
+    /**
+     * Session identifier: 32-char lowercase hex (16 bytes), generated by the
+     * sender per stream and echoed by the maker on every receipt.
+     */
+    streamNonce: string;
+    /**
+     * Maker's per-session fulfill counter, 1-based, strictly increasing by 1
+     * per fulfilled packet. Gaps observed by the sender indicate receipts it
+     * never received (hole detection).
+     */
+    seq: number;
+    /**
+     * Running total of asset B delivered in this session (target micro-units,
+     * decimal string). Monotone non-decreasing in `seq`; the latest receipt
+     * supersedes all earlier ones.
+     */
+    cumulativeDelivered: string;
+    /** The maker's quote `R_i` applied to the packet this receipt rode on (decimal string). */
+    rate: string;
+    /** Unix ms timestamp when the maker's rate source produced {@link rate}. */
+    rateTimestamp: number;
+}
+/**
+ * A signed stream receipt as carried on the FULFILL accept-metadata under
+ * the `receipt` key (rolling-swap spec §7.2).
+ */
+interface StreamReceipt extends StreamReceiptFields {
+    /**
+     * 128-char lowercase hex BIP-340 Schnorr signature by the maker's receipt
+     * key over `sha256(encodeReceiptSigningPayload(fields))`.
+     */
+    sig: string;
+}
+/**
+ * Aggregate view of the receipts harvested from one stream — the serialized
+ * audit/dispute artifact's in-memory shape. Returned on
+ * `StreamSwapResult.receipts` (present on abort too, covering what filled).
+ */
+interface StreamReceiptChain {
+    /** The sender-generated session nonce receipts were verified against. */
+    streamNonce: string;
+    /** All verified receipts, sorted by ascending `seq`. */
+    receipts: StreamReceipt[];
+    /** Highest-`seq` receipt — supersedes all others (rfc-0039 latest-wins). */
+    latest?: StreamReceipt;
+    /**
+     * `latest.cumulativeDelivered`, or `'0'` when no receipt was received —
+     * the signed total of asset B the maker attests to having delivered.
+     */
+    totalDelivered: string;
+    /**
+     * Missing `seq` values in `[1, latest.seq]`: fulfilled packets whose
+     * receipts the sender never received (lost FULFILLs, or maker skips).
+     */
+    holes: number[];
+}
+/** True iff `value` is a well-formed 32-char lowercase hex stream nonce. */
+declare function isValidStreamNonce(value: unknown): value is string;
+/**
+ * Structurally validate an untrusted metadata `receipt` value into a
+ * {@link StreamReceipt}. Checks shape ONLY — no signature or monotonicity
+ * verification (that is {@link verifyStreamReceipt} / {@link ReceiptChainTracker}).
+ *
+ * @throws {Error} with a human-readable reason when malformed. Callers
+ *   (e.g. `decodeFulfillMetadata`) wrap into their own error taxonomy.
+ */
+declare function parseStreamReceipt(value: unknown): StreamReceipt;
+/**
+ * Deterministic binary encoding of the signed receipt fields — the signing
+ * preimage. Layout (all integers big-endian):
+ *
+ * ```
+ * len(tag):u32 || tag(utf8) || v:u8 || streamNonce(16 raw bytes)
+ *   || seq:u64 || len:u32 || cumulativeDelivered(utf8)
+ *   || len:u32 || rate(utf8) || rateTimestamp:u64
+ * ```
+ *
+ * Length prefixes remove concatenation ambiguity between the variable-width
+ * decimal strings (same rationale as the swap-handler replay packet-id hash).
+ */
+declare function encodeReceiptSigningPayload(fields: StreamReceiptFields): Uint8Array;
+/**
+ * Sign the receipt fields with the maker's receipt secret key (32-byte
+ * secp256k1 scalar — by default the maker's Nostr identity key). Returns
+ * the complete {@link StreamReceipt} with the BIP-340 Schnorr `sig` over
+ * `sha256(encodeReceiptSigningPayload(fields))`.
+ */
+declare function signStreamReceipt(fields: StreamReceiptFields, secretKey: Uint8Array): StreamReceipt;
+/**
+ * Verify a receipt's Schnorr signature against the maker's receipt pubkey
+ * (64-char lowercase hex x-only key — by default the maker's `swapPubkey`).
+ * Authenticity only; monotonicity/session checks live in
+ * {@link ReceiptChainTracker}.
+ */
+declare function verifyStreamReceipt(receipt: StreamReceipt, makerPubkey: string): boolean;
+/** Outcome of {@link ReceiptChainTracker.add}. */
+type ReceiptAddResult = {
+    ok: true;
+} | {
+    ok: false;
+    /** Machine-readable rejection reason. */
+    code: 'BAD_SIGNATURE' | 'WRONG_STREAM_NONCE' | 'DUPLICATE_SEQ' | 'NON_MONOTONIC';
+    message: string;
+};
+/**
+ * Accumulates and verifies the receipt chain for ONE stream session.
+ *
+ * Per added receipt it checks, in order:
+ * 1. `streamNonce` matches the session (a receipt for another session is
+ *    worthless as proof for this one),
+ * 2. the Schnorr signature verifies against the maker's receipt pubkey,
+ * 3. `seq` is not a duplicate,
+ * 4. `cumulativeDelivered` is monotone in `seq` against every receipt seen
+ *    so far: non-decreasing with ascending `seq` (rfc-0039 "progressively
+ *    higher amount"; non-strict so a zero-target packet — possible under
+ *    `applyRate` truncation — does not read as maker equivocation).
+ *
+ * Receipts may be added OUT OF ORDER (adaptive W>1 streams complete in
+ * arbitrary order); monotonicity is enforced against both the nearest lower
+ * and nearest higher `seq` neighbors.
+ */
+declare class ReceiptChainTracker {
+    #private;
+    constructor(input: {
+        streamNonce: string;
+        makerPubkey: string;
+    });
+    get streamNonce(): string;
+    /** Number of verified receipts accumulated so far. */
+    get size(): number;
+    /**
+     * Verify + accumulate one receipt. On `{ok: false}` the receipt is NOT
+     * added and the chain is unchanged.
+     */
+    add(receipt: StreamReceipt): ReceiptAddResult;
+    /**
+     * Snapshot the accumulated chain: sorted receipts, the superseding latest,
+     * the signed total delivered, and any `seq` holes in `[1, latest.seq]`.
+     */
+    chain(): StreamReceiptChain;
+}
+/**
+ * Serialize a receipt chain into the portable audit/dispute artifact: a
+ * stable, versioned JSON document. Any third party holding the maker's
+ * receipt pubkey can re-verify every receipt in it offline (the enclosed
+ * receipts are self-contained signed statements).
+ */
+declare function serializeReceiptChain(chain: StreamReceiptChain): string;
+/** Per-session receipt issuance state kept by the maker. */
+interface ReceiptSessionState {
+    /** Last issued seq (0 = none issued yet). */
+    seq: number;
+    /** Cumulative asset-B delivered in the session so far (target micro-units). */
+    cumulativeDelivered: bigint;
+}
+/**
+ * Minimal synchronous store contract for maker-side receipt session state,
+ * keyed by `streamNonce`.
+ *
+ * SYNCHRONOUS by design: the swap handler performs the read-increment-write
+ * inside one microtask so concurrent packets in the same session get
+ * distinct, gapless `seq` values and consistent cumulative totals. An
+ * operator-supplied store that persists (e.g. alongside the claim/channel
+ * store, so receipt state survives restarts like claims do) should
+ * write-through asynchronously in the background while serving reads from
+ * memory. The default is {@link BoundedReceiptSessions} (in-memory LRU).
+ */
+interface ReceiptSessionStoreLike {
+    get(streamNonce: string): ReceiptSessionState | undefined;
+    set(streamNonce: string, state: ReceiptSessionState): unknown;
+    delete(streamNonce: string): boolean;
+}
+/**
+ * Default ceiling for the maker's receipt-session LRU. Same DoS rationale
+ * as `DEFAULT_SEEN_PACKET_IDS_CAP`: bounds memory against an attacker
+ * minting unlimited distinct stream nonces. An evicted (or maker-restarted)
+ * session restarts at seq 1 — the sender's tracker then rejects the
+ * duplicate seq loudly rather than accepting a forked chain.
+ */
+declare const DEFAULT_RECEIPT_SESSIONS_CAP = 10000;
+/**
+ * Bounded in-memory LRU {@link ReceiptSessionStoreLike}. Access-order
+ * eviction: active sessions stay pinned while stale ones age out.
+ */
+declare class BoundedReceiptSessions implements ReceiptSessionStoreLike {
+    #private;
+    constructor(cap?: number);
+    get size(): number;
+    get cap(): number;
+    get(streamNonce: string): ReceiptSessionState | undefined;
+    set(streamNonce: string, state: ReceiptSessionState): this;
+    delete(streamNonce: string): boolean;
+}
+/**
+ * Maker-side: advance the session state for one fulfilled packet and issue
+ * the corresponding signed receipt. The read-increment-write against the
+ * store happens synchronously (no awaits) so concurrent handler invocations
+ * interleave safely.
+ *
+ * MUST only be called for a packet that is being ACCEPTED — a rejected
+ * packet gets no receipt and MUST NOT advance the session.
+ */
+declare function issueSessionReceipt(input: {
+    sessions: ReceiptSessionStoreLike;
+    streamNonce: string;
+    /** Asset-B amount delivered by THIS packet (target micro-units). */
+    deliveredAmount: bigint;
+    /** The quote-tape rate applied to this packet. */
+    rate: string;
+    /** The quote-tape timestamp for {@link rate}. */
+    rateTimestamp: number;
+    /** Maker receipt secret key (32-byte secp256k1). */
+    secretKey: Uint8Array;
+}): StreamReceipt;
+
 /**
  * Adaptive δ/W controller for rolling swaps (issue #83, rolling-swap spec §6).
  *
@@ -633,6 +900,29 @@ interface StreamSwapParams {
      * optional and only the soft deviation monitor applies.
      */
     minExchangeRate?: string;
+    /**
+     * Maker receipt verification key (issue #84, rfc-0039 stream receipts;
+     * rolling-swap spec §7.2): 64-char lowercase hex x-only pubkey each
+     * per-fulfill receipt's BIP-340 signature is verified against. Defaults
+     * to `swapPubkey` (the maker identity key — the swap handler's default
+     * receipt signer). Set when the maker provisioned a dedicated receipt key
+     * (`CreateSwapHandlerConfig.receiptSecretKey`, e.g. the swap#47 coupled
+     * engine's chain-B claim signer key).
+     */
+    receiptPubkey?: string;
+    /**
+     * When true, every fulfilled packet MUST carry a verifiable receipt: a
+     * receipt-less FULFILL is recorded as a `RECEIPT_MISSING` rejection and
+     * the stream halts with `abortReason: 'receipt-invalid'` (a maker that
+     * doesn't attest deliveries cannot be audited, so keep the exposure at
+     * zero). When omitted/false, receipt-less fulfills from legacy makers
+     * degrade gracefully: the claim still accumulates, `result.receipts`
+     * is simply empty. A receipt that is PRESENT but fails verification
+     * (tampered, wrong key, wrong session, non-monotone, duplicate seq) is
+     * ALWAYS a loud `RECEIPT_INVALID` rejection + halt, regardless of this
+     * flag — the packet's claim is never accumulated.
+     */
+    requireReceipts?: boolean;
     /** Per-packet timeout in ms. Default 30000. */
     packetTimeoutMs?: number;
     /**
@@ -703,6 +993,13 @@ interface PacketProgress {
     rate?: string;
     /** Unix ms timestamp when the maker's rate source produced {@link rate}. Present iff `rate` is. */
     rateTimestamp?: number;
+    /**
+     * Verified per-fulfill stream receipt (issue #84, rolling-swap spec §7.2).
+     * Present iff the maker emitted a receipt AND it verified (signature,
+     * session nonce, monotonicity) — an invalid receipt halts the stream
+     * before the callback ever fires for that packet.
+     */
+    receipt?: StreamReceipt;
     /** Controller state at callback time. */
     state: 'running' | 'paused' | 'stopped';
 }
@@ -757,6 +1054,12 @@ interface AccumulatedClaim {
     rate?: string;
     /** Unix ms timestamp when the maker's rate source produced `rate`. Present iff `rate` is. */
     rateTimestamp?: number;
+    /**
+     * The VERIFIED signed receipt that rode on this packet's FULFILL
+     * (issue #84, rolling-swap spec §7.2) — receipts persist wherever the
+     * claim does. Present iff the maker emitted receipts for this session.
+     */
+    receipt?: StreamReceipt;
 }
 /**
  * Aggregate result of a `streamSwap()` invocation.
@@ -776,11 +1079,21 @@ interface StreamSwapResult {
         packetIndex: number;
         cause: Error;
     }[];
-    abortReason: 'complete' | 'aborted' | 'stopped' | 'callback-stop' | 'callback-throw' | 'rate-deviation' | 'below-floor' | 'all-rejected';
+    abortReason: 'complete' | 'aborted' | 'stopped' | 'callback-stop' | 'callback-throw' | 'rate-deviation' | 'below-floor' | 'receipt-invalid' | 'all-rejected';
     cumulativeSource: bigint;
     cumulativeTarget: bigint;
     packetsSent: number;
     packetsScheduled: number;
+    /**
+     * The verified receipt chain for this stream (issue #84, rolling-swap
+     * spec §7.2): every receipt that verified against the maker receipt key,
+     * sorted by `seq`, plus the superseding `latest`, the signed
+     * `totalDelivered`, and any `seq` holes. ALWAYS present — on abort it
+     * covers exactly what filled before the halt; against a legacy maker
+     * (no receipt support) it is simply empty. Feed to
+     * `serializeReceiptChain()` for the portable audit/dispute artifact.
+     */
+    receipts: StreamReceiptChain;
 }
 /** External controller returned by {@link streamSwapControlled}. */
 interface StreamSwapController {
@@ -798,6 +1111,12 @@ declare function chunkAmount(total: bigint, count: number): bigint[];
  * `pair.to.chain`. The value is echoed verbatim per packet — no case-folding
  * or transformation beyond what the sender-side `validateChainAddress`
  * accepts.
+ *
+ * Issue #84 (rfc-0039 stream receipts): when `streamNonce` is provided, the
+ * rumor also carries a `stream-nonce` tag — the sender-generated session
+ * identifier a receipt-capable maker echoes on every per-fulfill receipt.
+ * This is the TOON analogue of rfc-0039's Verifier→Receiver Receipt-Nonce
+ * provisioning (in-band, per stream). Legacy makers ignore the unknown tag.
  */
 declare function buildSwapRumor(input: {
     senderPubkey: string;
@@ -808,6 +1127,8 @@ declare function buildSwapRumor(input: {
     nonce: Uint8Array;
     createdAt: number;
     chainRecipient: string;
+    /** 32-char lowercase hex session nonce (issue #84 stream receipts). */
+    streamNonce?: string;
 }): UnsignedEvent;
 /**
  * Decode the FULFILL response `data` (base64-encoded JSON metadata) into
@@ -832,6 +1153,16 @@ declare function buildSwapRumor(input: {
  * permitted for legacy makers unless `opts.requireQuoteTape` is set (which
  * `runLoop` does whenever `minExchangeRate` is armed).
  *
+ * Issue #84 extension (rfc-0039 stream receipts, spec §7.2): parses the
+ * optional `receipt` object into a structurally-validated {@link StreamReceipt}.
+ * Like the tape, a PRESENT-but-malformed receipt is a loud
+ * `FULFILL_DECODE_FAILED` (a garbled proof must never be silently dropped —
+ * the sender would keep streaming while its audit artifact rots); a wholly
+ * absent receipt is legacy-maker territory and tolerated here (the
+ * `requireReceipts` policy is enforced by the caller, which has the halt
+ * machinery). Signature/monotonicity verification is NOT done here — that is
+ * `processAcceptedPacket`'s ReceiptChainTracker.
+ *
  * @param chain Optional `pair.to.chain` string for per-chain format validation
  *   of channelId / recipient / swapSignerAddress. When omitted, format checks
  *   fall back to a length-only sanity check.
@@ -850,6 +1181,8 @@ declare function decodeFulfillMetadata(data: string | undefined, chain?: string,
     rate?: string;
     /** Quote-tape timestamp (unix ms). Present iff `rate` is. */
     rateTimestamp?: number;
+    /** Per-fulfill stream receipt (issue #84) — structurally validated, NOT yet signature-verified. */
+    receipt?: StreamReceipt;
     channelId?: string;
     nonce?: string;
     cumulativeAmount?: string;
@@ -908,4 +1241,4 @@ declare const __testing: {
     compareDecimalRates: typeof compareDecimalRates;
 };
 
-export { type AccumulatedClaim as A, type StreamSwapClient as B, type DecryptFulfillClaimParams as D, type EncryptFulfillClaimParams as E, InMemorySwapControllerStateStore as I, JsonFileSwapControllerStateStore as J, type PacketObservation as P, type RateMonitorCallback as R, type StreamSwapAdaptiveController as S, type UnwrapSwapPacketFromToonParams as U, type WrapSwapPacketParams as W, __testing as _, AdaptiveDeltaController as a, type AdaptiveDeltaControllerConfig as b, type EncryptFulfillClaimResult as c, type PacketProgress as d, type PacketResolution as e, type StreamSwapController as f, type StreamSwapParams as g, type StreamSwapResult as h, SwapControllerError as i, type SwapControllerState as j, type SwapControllerStateStore as k, type UnwrapSwapPacketParams as l, type UnwrapSwapPacketResult as m, type WrapSwapPacketResult as n, type WrapSwapPacketToToonParams as o, type WrapSwapPacketToToonResult as p, decryptFulfillClaim as q, encryptFulfillClaim as r, isSwapControllerState as s, streamSwap as t, streamSwapControlled as u, swapControllerStateKey as v, unwrapSwapPacket as w, unwrapSwapPacketFromToon as x, wrapSwapPacket as y, wrapSwapPacketToToon as z };
+export { wrapSwapPacket as $, type AccumulatedClaim as A, BoundedReceiptSessions as B, decryptFulfillClaim as C, DEFAULT_RECEIPT_SESSIONS_CAP as D, type EncryptFulfillClaimParams as E, encodeReceiptSigningPayload as F, encryptFulfillClaim as G, isSwapControllerState as H, InMemorySwapControllerStateStore as I, JsonFileSwapControllerStateStore as J, isValidStreamNonce as K, issueSessionReceipt as L, parseStreamReceipt as M, serializeReceiptChain as N, signStreamReceipt as O, type PacketObservation as P, streamSwap as Q, type ReceiptSessionStoreLike as R, STREAM_RECEIPT_SIGNING_TAG as S, streamSwapControlled as T, type UnwrapSwapPacketFromToonParams as U, swapControllerStateKey as V, type WrapSwapPacketParams as W, unwrapSwapPacket as X, unwrapSwapPacketFromToon as Y, verifyStreamReceipt as Z, __testing as _, AdaptiveDeltaController as a, wrapSwapPacketToToon as a0, type StreamSwapClient as a1, type AdaptiveDeltaControllerConfig as b, type DecryptFulfillClaimParams as c, type EncryptFulfillClaimResult as d, type PacketProgress as e, type PacketResolution as f, type RateMonitorCallback as g, type ReceiptAddResult as h, ReceiptChainTracker as i, type ReceiptSessionState as j, STREAM_RECEIPT_VERSION as k, type StreamReceipt as l, type StreamReceiptChain as m, type StreamReceiptFields as n, type StreamSwapAdaptiveController as o, type StreamSwapController as p, type StreamSwapParams as q, type StreamSwapResult as r, SwapControllerError as s, type SwapControllerState as t, type SwapControllerStateStore as u, type UnwrapSwapPacketParams as v, type UnwrapSwapPacketResult as w, type WrapSwapPacketResult as x, type WrapSwapPacketToToonParams as y, type WrapSwapPacketToToonResult as z };

package/dist/swap.d.ts

@@ -1,3 +1,3 @@
-export { A as AccumulatedClaim, d as PacketProgress, R as RateMonitorCallback, B as StreamSwapClient, f as StreamSwapController, g as StreamSwapParams, h as StreamSwapResult, q as decryptFulfillClaim, t as streamSwap, u as streamSwapControlled, z as wrapSwapPacketToToon } from './swap-Oub-0vqU.js';
+export { A as AccumulatedClaim, B as BoundedReceiptSessions, e as PacketProgress, g as RateMonitorCallback, h as ReceiptAddResult, i as ReceiptChainTracker, j as ReceiptSessionState, R as ReceiptSessionStoreLike, k as STREAM_RECEIPT_VERSION, l as StreamReceipt, m as StreamReceiptChain, n as StreamReceiptFields, a1 as StreamSwapClient, p as StreamSwapController, q as StreamSwapParams, r as StreamSwapResult, C as decryptFulfillClaim, F as encodeReceiptSigningPayload, K as isValidStreamNonce, L as issueSessionReceipt, M as parseStreamReceipt, N as serializeReceiptChain, O as signStreamReceipt, Q as streamSwap, T as streamSwapControlled, Z as verifyStreamReceipt, a0 as wrapSwapPacketToToon } from './swap-PFQTJZA7.js';
 import 'nostr-tools/pure';
 import '@toon-protocol/core';

package/dist/swap.js

@@ -1,14 +1,34 @@
 import {
+  BoundedReceiptSessions,
+  ReceiptChainTracker,
+  STREAM_RECEIPT_VERSION,
   decryptFulfillClaim,
+  encodeReceiptSigningPayload,
+  isValidStreamNonce,
+  issueSessionReceipt,
+  parseStreamReceipt,
+  serializeReceiptChain,
+  signStreamReceipt,
   streamSwap,
   streamSwapControlled,
+  verifyStreamReceipt,
   wrapSwapPacketToToon
-} from "./chunk-7LBYFU4L.js";
+} from "./chunk-RAZRWSJF.js";
 import "./chunk-UP2VWCW5.js";
 export {
+  BoundedReceiptSessions,
+  ReceiptChainTracker,
+  STREAM_RECEIPT_VERSION,
   decryptFulfillClaim,
+  encodeReceiptSigningPayload,
+  isValidStreamNonce,
+  issueSessionReceipt,
+  parseStreamReceipt,
+  serializeReceiptChain,
+  signStreamReceipt,
   streamSwap,
   streamSwapControlled,
+  verifyStreamReceipt,
   wrapSwapPacketToToon
 };
 //# sourceMappingURL=swap.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toon-protocol/sdk",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "TOON SDK for building ILP-gated Nostr services",
   "type": "module",
   "main": "./dist/index.js",