Skip to content

v0.17.0

Choose a tag to compare

@tempo-github-sts tempo-github-sts released this 25 Oct 16:44
· 73 commits to main since this release
Immutable release. Only release title and notes can be modified.
4d0c739

Minor Changes

  • With prepaid requests and a top-up amount configured, TempoSessionProvider tops a session channel up in the background once its deposit no longer covers the prepaid balance plus the next request, so the on-chain top-up does not hold up a later request. (by @brendanryan, #630)
  • Added MppError::CredentialReplayed and ErrorCode::CredentialReplayed: replayed Tempo charge credentials (used transaction hashes and proofs, duplicate submissions, settled transfers whose memo is bound to another challenge) are now answered with a 403 verification-failed problem and no WWW-Authenticate challenge or challengeId, so clients do not pay again. A transaction credential whose broadcast or settlement failed releases its submission claim, as in mppx, so resending it retries instead of being rejected as a replay. (by @brendanryan, #630)
  • Add ChargeMethod::validate_expected_request so payment methods can compare
  • selected method-specific fields against a route's expected charge request before
  • validation or broadcast. The default accepts additional fields, preserving
  • existing methods, and all existing core comparisons and credential checks remain
  • in place. (by @brendanryan, #630)
  • Exposed the payer verified by charge validation as payer on ChargeValidation and PaymentSuccessContext; Tempo charge validation reports the transaction sender, the proof signer, or the account the matched transfers of a hash credential debited. (by @brendanryan, #630)
  • Added ForwardProxy behind the forward-proxy feature: a local HTTP forward proxy that lets programs that know nothing about MPP, such as curl, pay for MPP services. It terminates TLS for the origins its AcceptPaymentPolicy allows with certificates from a per-process certificate authority, pays 402 challenges with a provider per origin, retries and streams the response back, and tunnels every other host untouched. ForwardProxy::environment returns the proxy and trust variables for child processes, and directory::service_urls fetches the services listed in an MPP directory such as mpp.dev's. (by @brendanryan, #630)
  • PaymentResponseContext::funding_currency reports the token the payer actually spent, through the new PaymentProvider::funding_currency. TempoAccountsProvider reports MACH when it pays a machine-token-enabled charge through the swapper and the autoswap input token when it swaps, so clients can label a charge correctly even when the server's receipt does not say how it was funded. MCP clients can read it from the provider before committing a payment. (by @brendanryan, #630)
  • Fund machine-token charges with MACH through its canonical swapper, matching mppx; the legacy machineUSD session route keeps its deployment. TempoAccountsProvider::with_preferred_currency now selects the first charge or session funded from the preferred currency across intents, including machine-token-enabled charges when the preferred currency is MACH. Add with_fee_token and with_session_fee_token so sessions denominated in a recipient-restricted token, such as MACH channels under TIP-1095, can pay unsponsored gas in another token. Add TempoSessionProvider::acknowledge_accepted so metered SSE responses, whose payment-receipt and payment-need-voucher events report acceptance in the body rather than a Payment-Receipt header, can resolve a pending channel open, and TempoAccountsProvider::session to reach the session provider that pays its challenges. A pending open whose authorization is already settled on-chain is resolved before the next voucher and on restore. TempoAccountsProvider reuses one settlement RPC client per URL instead of opening a connection for every charge, and machine-token route discovery reads the balance and simulates the route concurrently. (by @brendanryan, #630)
  • Session channels can be topped up and closed over MCP. A ManagementTransport delivers a management credential to the resource that issued its challenge, and PaymentProvider::pay_with_management pays a challenge with any top-up the payment needs sent through it instead of HTTP. It defaults to pay_with_context; TempoSessionProvider, TempoAccountsProvider and MultiProvider implement it. TempoSessionProvider::close_with closes a channel through a transport.
  • mcp::client::McpManagement is the MCP transport: it repeats a tool call with the credential in _meta, as mppx's MCP server and Mercator accept top-ups and closes, and returns the receipt of the server's receipt-only result. McpClient tops a channel up this way when its deposit does not cover the call, and McpClient::management returns the transport for closing. Before, an MCP session whose deposit ran out failed with session cumulative amount exceeds channel deposit.
  • ToolCaller::receipt_from_output and mcp::extract_receipt read a result's receipt. McpClient passes the receipt of each paid call to the provider, and McpPayment::record_receipt does so for SDK adapters that run their own retry. (by @brendanryan, #630)
  • Report what payments cost and where money moves, so clients can show spending without tracking channels themselves:
  • PaymentResponseContext::amount is what the server charged for the request: a charge's amount, or for a session the change in the channel's spent from the receipt. Providers report session costs through the new PaymentProvider::record_receipt, which defaults to observe_receipt and no amount.
  • A new channel.deposit event (ClientEvent::Deposit, ClientEvents::on_deposit) reports when the server accepts a session channel's open or a top-up, including background top-ups, with the URL, channel, token, amount added and resulting deposit. Enable it with TempoSessionProvider::with_events or TempoAccountsProvider::with_session_events.
  • PaymentProvider::stream_event lets a provider answer payment events in a response stream; TempoSessionProvider and TempoAccountsProvider answer mppx payment-need-voucher and payment-receipt. ForwardProxy uses it for paid text/event-stream responses, so a session stream that asks for more vouchers keeps flowing to a client that knows nothing about MPP. (by @brendanryan, #630)
  • Answer bare 402 challenges with an RFC 9457 application/problem+json
  • payment-required problem, as mppx does, instead of {"error": "Payment Required"}.
  • This applies to the axum PaymentRequired and PaymentOffers responses and to
  • HttpTransport::respond_challenge.
  • ChallengeContext::error is now Option<&MppError> (was Option<&str>):
  • HttpTransport sends the error's problem details with its status, and
  • WsTransport sends the problem's detail.
  • A 500 problem, sent without a challenge, carries no challengeId. (by @brendanryan, #630)
  • PaymentResponseContext now carries the paid request's url and the response's boxed receipt, so payment.response handlers can show who was paid and the settlement reference (a charge's transaction or a session's channel) without parsing headers. A session receipt is included only when it matches the challenge and the paying channel, as before. (by @brendanryan, #630)
  • Added prepaid session vouchers. TempoSessionProvider::with_prepaid_requests (and TempoAccountsProvider::with_session_prepaid_requests) keep a few requests' worth of balance, at the latest request's price, prepaid on the channel, and send the voucher with the next request to the same URL instead of waiting for a 402. This needs a server whose session challenges are reusable (mppx reusableChallenges); any 402 falls back to the normal flow. PaymentProvider gains the prepaid_credential and observe_receipt hooks the payment flow uses for this. (by @brendanryan, #630)
  • TempoAccountsProvider::preconnect primes the first prepaid voucher. After restoring a session channel, it asks the server again with a Payment-Session header naming that channel and reads the session snapshot in the challenge. TempoSessionProvider::prime_prepaid sizes the URL's first prepaid voucher from the snapshot's spent. The first request of a new process then carries its voucher instead of waiting for a 402, and when earlier vouchers already cover the server's spent plus the request, it raises the cumulative amount by one unit instead of by the request's price. TempoSessionProvider::restored_channel_id reports the in-memory channel a challenge would pay from. (by @brendanryan, #630)
  • Added send_with_exchange and made Exchange and FlowError public, so the HTTP 402 payment flow can run over a host application's HTTP stack instead of a reqwest::Client. Request failures keep the exchange's own error type. (by @brendanryan, #630)
  • Add ChargeClient for explicitly authorized charge payments using either
  • Authorization or Payment-Authorization. The SDK owns the HTTP client and
  • disables redirects for initial requests and paid retries. Session offers are
  • filtered before provider preparation, and the prepaid-credential hook is skipped.
  • Existing Fetch, middleware, and session management custom-header restrictions
  • remain in place. (by @brendanryan, #630)
  • Added SDK helpers for session clients. TempoAccountsProvider::with_sqlite_session_store opens the shared SQLite channel store namespaced by a service's origin, and TempoAccountsProvider::preconnect sends an unpaid probe and restores the channel it would pay. TempoSessionProvider::spend reports what the server charged for requests paid through the provider and the deposit left, from payment receipts, and TempoSessionProvider::stream_event handles mppx payment-need-voucher and payment-receipt SSE events. (by @brendanryan, #630)
  • Added TempoSessionProvider::restore, which loads the channel a session challenge would pay from the durable store into memory, checked against chain state, without signing, so a client can prepare before its first paid request. (by @brendanryan, #630)
  • TempoAccountsProvider's with_session_* settings (deposit, top-up, maximum deposit, fee token, prepaid requests, events) no longer depend on the session store: they apply whether they are set before or after with_session_store, and survive a store change. A configured wallet's with_sqlite_session_store(service) is therefore that service's wallet, with the same settings and its own channels, instead of silently dropping settings set earlier. (by @brendanryan, #630)
  • sse::ServeOptions and ws_session::WsSessionOptions take a before_charge check that runs before each value is charged and delivered, and SessionMethod::stream_check provides one that stops the stream when the channel's on-chain escrow has a pending close, was withdrawn, or cannot be read, caching successful reads for five seconds and counting amounts settled on chain above the highest accepted voucher as spent (settling an accepted voucher keeps its unspent credit). The check runs once per value, not on every poll while the stream waits for a voucher. (by @brendanryan, #630)
  • TempoSessionProvider::stream_event records the spent of each payment-receipt event that a streaming response carries. Servers send these events when they charge a request while its output is delivered or settle it at its final usage. When spent changed, the provider adds the change to its spend ledger, so spend() follows the stream, and emits the new ClientEvent::PaymentUpdate (payment.update, PaymentUpdateContext with the URL, channel, new spent and signed change). ClientEvents::on_payment_update subscribes to it. (by @brendanryan, #630)
  • Added with_currencies, with_max_amount and with_max_atomic_amount to TempoProvider so clients skip and refuse charges in other currencies or above a per-charge cap. MultiProvider now falls through to the next payment method when a provider rejects all of its offers. (by @brendanryan, #630)
  • Servers verify TIP-1034 channel reserve precompile sessions: when a session's escrow is the precompile, open, voucher, topUp and close credentials must carry a channel descriptor that hashes to the channel id, opens are checked against the descriptor (payer, payee, operator, token, salt, signer, expiringNonceHash), vouchers accept TIP-1020 primitive signatures (so P-256 access keys can pay), state is read with getChannelState, and closes require the cooperative close authorization and capture only what was spent. Legacy escrow sessions are unchanged. (by @brendanryan, #630)
  • Add opt-in RFC 9457 JSON bodies to PaymentLayer and PaymentBodyLayer with
  • with_problem_details. Applications supply a JSON-bytes-to-body callback while
  • existing layers retain empty response bodies by default. Payment rejections keep
  • their status and retry challenge; internal failures return a generic 500 problem
  • without exposing backend details.
  • Generated 400 and 413 responses from these layers now carry
  • Cache-Control: no-store, with or without problem details.
  • Untyped PaymentVerifier::verify errors, including those from from_fns, are
  • reported as a generic verification-failed problem without the verifier's message. (by @brendanryan, #630)

Patch Changes

  • Raised the Authorization credential size limit from 16 KiB to 64 KiB, matching mppx, and applied it to the raw header before scheme extraction. A credential echoes its challenge, so credentials for challenges with a request near its 16 KiB limit or a large opaque were rejected even though mppx accepts them. extract_payment_scheme now returns None for headers over 64 KiB instead of tokenizing them. Challenge request and receipt limits are unchanged. (by @brendanryan, #630)
  • Reject zero-amount Tempo charge proofs when a payment challenge names a realm other than the requested host. Apply the check to HTTP payments, session bootstrap, MCP payments, and WebSocket clients. Respect a caller-supplied HTTP Host header, and allow a different server realm only when explicitly pinned to its HTTP origin with with_trusted_tempo_proof_realm.
  • The Axum extractors can use the HTTP request hostname as the default challenge realm and verify against the same realm, matching mppx when the hostname is configured through .trusted_hosts([...]). This explicit list prevents a client-controlled Host header from choosing a victim server's proof realm. An explicit .realm(...) or MPP_REALM still takes precedence. Unlisted hosts and servers issuing challenges outside an HTTP request (such as direct Mpp::charge calls or WebSocket handlers) continue to use their configured or environment-detected realm; those servers must configure a realm matching their public hostname or clients must pin the realm to its HTTP origin. Without that configuration, zero-amount Tempo proofs fail closed. (by @brendanryan, #630)
  • Bounded each session management request (top-up, voucher and close), including reading an error response's body, to 30 seconds, failing with an unknown payment outcome instead of holding the payment lock while a server stalls. A top-up whose outcome is unknown, including one whose management transport fails with MppError::Http, blocks further top-ups on that channel until it is reconciled, so a late-applied deposit is not signed again. (by @brendanryan, #630)
  • ws_session::process_vouchers now rejects inbound WebSocket frames larger than the new MAX_INCOMING_MESSAGE_BYTES (64 KiB) before parsing them: it sends a payment message is too large error frame and ends processing with an InvalidPayload error. The deprecated process_incoming_vouchers skips such a frame unparsed and keeps reading until the connection ends. (by @brendanryan, #630)
  • TIP-1034 close credentials carry the cooperative close authorization (closeSignature), a distinct EIP-712 CloseAuthorization signature over the channel and amount that mppx servers have required since 0.13.1. Without it, TempoSessionProvider::close and close_with were rejected by mppx 0.13 and 0.14 servers, including tempoxyz/mpp-proxy and Mercator. precompile_close_authorization_signing_hash_with_escrow and the sign_precompile_close_authorization* functions are exported, and the hash matches viem's for mppx's typed data. (by @brendanryan, #630)
  • compose_verify_with_expected_requests now dispatches a credential to the route whose handler issued its challenge for that route's expected request when several routes share a payment method, such as two Tempo handlers with different currencies, recipients or scopes, instead of checking it against the first handler for that method. Added ChargeVerifier::issued_credential_for, which Mpp implements with its challenge HMAC and expected-request checks (including every currency it offers). (by @brendanryan, #630)
  • Sessions now read on-chain channel state concurrently with the stored channel when accepting a voucher; stored-channel errors still take precedence over a failed on-chain read. (by @brendanryan, #630)
  • Signed server session close transactions with an expiring nonce instead of the close signer's sequential nonce, so independent server processes sharing a close signer no longer race for the same nonce.
  • The pending close records the transaction's valid_before, and reconciliation releases a channel whose close is still unmined 30 seconds past it (matching mppx's clock-skew margin), so a close that can no longer land does not leave the channel stuck in closing. For TIP-1034 channels it reads the precompile's getChannelState at a block past valid_before and releases the channel only while it is still funded with no close request, as mppx does; otherwise the channel stays blocked. (by @brendanryan, #630)
  • Tempo charge transactions now cap validBefore at the second after the challenge expires instead of flooring it, so a fractional or current-instant expiry no longer yields an already-passed deadline. (by @brendanryan, #630)
  • Background session top-ups read chain state and sign without holding the payment lock, which they now take only to record the new deposit. (by @brendanryan, #630)
  • Paid gas for unsponsored charges funded with MACH (a MACH charge or a MACH swapper route) in a funded stablecoin (pathUSD, then the network's default currency), since MACH cannot pay its own fees. Only the chain's canonical MACH deployment triggers this. (by @brendanryan, #630)
  • McpPayment::prepare, prepare_with_management and McpClient::call_tool pay the next supported challenge in preference order when paying the preferred one fails, and return the first failure only when none can be paid. A wallet that cannot fund a session's suggested deposit, such as Mercator's 5 MACH minimum, now pays the server's one-time charge instead of failing the call. (by @brendanryan, #630)
  • When a paid retry, or a request sent with a prepaid credential, returns a 5xx response or fails to send, the client now emits payment.failed with PaymentFailureReason::OutcomeUnknown, carrying the status, the serialized credential and, for Tempo hash charge credentials, the transaction hash, and still returns the response. A 5xx without a receipt now keeps the provider's optimistic payment state, as a lost response does, instead of rolling it back. (by @brendanryan, #630)
  • scrub_response_headers now strips payment protocol headers an upstream service returns (Accept-Payment, Payment-Authorization, Payment-Receipt, Payment-Required, Payment-Response, Payment-Session, Payment-Session-Snapshot, Payment-Signature), drops Authorization values using the Payment scheme, and removes Payment challenges from WWW-Authenticate while keeping other schemes. Proxied requests also strip Payment-Session and Payment-Session-Snapshot.
  • A Payment challenge hidden by a quote that opens on one WWW-Authenticate line and closes on the next is dropped too, and the auth-param tokenizer now reads long comma-separated values in linear time. (by @brendanryan, #630)
  • Tempo charge receipts now report fundingCurrency, the token the payer spent, when the payment uses a recognized route: the payment currency for direct transfers, the DEX swap input token, or MACH for the machine-token swapper route. Transaction credentials read it from the signed transaction; final hash credential receipts look the transaction up once. Unrecognized routes, other senders, failed lookups and zero-amount proofs omit it without changing payment acceptance. Add Receipt::with_funding_currency and Receipt::funding_currency. (by @brendanryan, #630)
  • Re-check Tempo charge challenge expiry right before broadcasting a transaction credential (and before accepting a proof), and treat an expires equal to the current time as expired. (by @brendanryan, #630)
  • Recover a Tempo charge whose eth_sendRawTransactionSync call returns an RPC error after the node included the transaction: the server now looks up the receipt for the broadcast hash and, if it exists, verifies it like a normal reply instead of failing the paid request. Matches mppx. Recovery runs only when a replay store reserved the submission, so a server without one never re-accepts an already-mined transaction; an unrecovered broadcast releases its reservation so a retry can recover the charge once it lands. (by @brendanryan, #630)
  • Removed the obsolete mpp_version and mpp_is_mpp metadata from Stripe charge PaymentIntents, matching mppx. (by @brendanryan, #630)
  • Serialized session top-ups per payment scope, including background top-ups, and rechecked the deposit after waiting so concurrent requests through one provider no longer fund a channel twice or past max_deposit. A wait for another top-up ends when the challenge expires, and a background top-up's channel.deposit event reports only its own increase. (by @brendanryan, #630)
  • TempoAccountsProvider now applies its expected chain ID to session payments as it does to charges: a session challenge for another chain is rejected with MppError::ChainIdMismatch instead of being paid with the expected chain's key and RPC. Prepaid session vouchers are checked against the pin too, and clones re-pinned to another chain no longer reuse a session provider built for the previous chain. (by @brendanryan, #630)
  • Stop charging session channels after the payer requested a forced close, as mppx does.
  • deduct_from_channel now rejects a channel with a pending close request, as it already
  • did for a closing or finalized one, so sse::serve and ws_session stop with the final
  • receipt instead of delivering service the payer can withdraw before it is settled. (by @brendanryan, #630)
  • Sessions pay gas for sponsored channel opens and top-ups in the feeToken the server advertises. Clients defaulted to the session currency, so a sponsored MACH channel named MACH as its gas token and the server rejected it. (by @brendanryan, #630)
  • Session payments and prepaid vouchers raise a channel held in process memory to the cumulative amount and deposit recorded in the channel store before signing. When processes share a store, a process that had not used a channel since another process paid with it no longer signs a voucher that the server rejects as not greater than its highest accepted voucher. (by @brendanryan, #630)
  • Sponsored charge transactions that install an access key are now rejected unless the server opts in with TempoBuilder::fee_payer_allow_key_authorization(true) (or ChargeMethod::with_fee_payer_allow_key_authorization(true)), matching mppx. Previously the fee payer sponsored key authorizations by default. (by @brendanryan, #630)
  • Require at least 15 seconds of remaining validity (valid_before) before co-signing a fee-sponsored Tempo charge transaction and again before broadcasting it, matching mppx, so the sponsor does not pay for a transaction that can expire in flight. (by @brendanryan, #630)
  • Enforce the 15-second remaining-validity floor for fee-sponsored charges at issuance: the client refuses to sign a sponsored challenge that expires in under 15 seconds, and the server refuses to issue a sponsored charge challenge whose expires is under 15 seconds away (zero-amount proof charges are exempt, since nothing is co-signed). The client's default expiring-nonce valid_before window stays at 25 seconds, matching mppx and Tempo's 30-second expiring-nonce maximum. A sponsor max_validity_window_seconds below 15 seconds is now rejected as misconfigured, and the window is counted from the current time rounded up, as in mppx. (by @brendanryan, #630)
  • Standardized Stripe PaymentIntent analytics metadata to match mppx: every PaymentIntent records machine_payment, the SDK identifier mpp_sdk (mpp-rs/<version>), mpp_challenge_id and mpp_intent, and no longer records mpp_server_id or mpp_client_id. Challenge methodDetails.metadata is applied after these keys. (by @brendanryan, #630)
  • A Stripe charge credential whose externalId does not match the request-bound externalId (or omits it) is now rejected with the invalid-challenge problem (402), matching mppx's InvalidChallengeError, instead of verification-failed. It is still rejected before any PaymentIntent is created. (by @brendanryan, #630)
  • Background session top-ups hold the payment lock and store lease only while the top-up is signed and recorded, not while it is submitted, so vouchers for concurrent requests are not delayed. Recording a top-up raises the current channel entry's deposit instead of writing back the entry it was signed against. (by @brendanryan, #630)
  • The default ChargeChallenger::verify_payment_for_amount_and_scope and verify_payment_for_amount_scope_and_body now verify framework route binding, as mppx does: instead of rejecting every scoped request, they re-issue the route's challenge with challenge (or challenge_with_body) and accept a credential only when its echoed challenge carries the route's _mppx_scope and the same method, intent, body digest and pinned request fields (amount, currency, recipient and method details, as in mppx), so a description the re-issued challenge lacks does not reject it, so a credential issued for another route, amount, HTTP method or body is rejected. Custom challengers that bind ChallengeOptions::mppx_scope into a deterministic challenge request now work with the Axum extractors without overriding these methods; their verify_payment must still authenticate the echoed challenge. (by @brendanryan, #630)
What's Changed
  • feat(tempo): MACH sessions and charges, streamed session acceptance, RPC reuse by @gakonst in #581
  • fix(tempo): pay sponsored session gas in the advertised fee token by @gakonst in #582
  • feat(client): prepaid session vouchers by @gakonst in #583
  • feat(client): restore a session channel without paying by @gakonst in #584
  • feat(client): top session channels up in the background by @gakonst in #585
  • perf(client): sign vouchers while a background top-up is submitted by @gakonst in #586
  • perf(client): prepare background top-ups without the payment lock by @gakonst in #587
  • feat(client): public payment exchange by @gakonst in #588
  • feat(client): SDK helpers for session clients by @gakonst in #589
  • feat(client): forward proxy that pays for 402 responses by @gakonst in #590
  • feat(client): payment.response carries the URL and receipt by @gakonst in #591
  • feat(client): report payment costs, channel deposits and answer stream payments by @gakonst in #592
  • chore(client): name the prepaid credential future type by @gakonst in #593
  • feat(client): keep session settings across session stores by @gakonst in #594
  • feat(client): report the token that funded a payment by @gakonst in #595
  • fix(client): sign session vouchers above what other processes recorded by @gakonst in #596
  • feat(client): prime the first prepaid voucher from the session snapshot by @gakonst in #597
  • chore: pin gh-actions references to 35019557 by @sds in #598
  • feat(client): follow in-stream session charges with payment.update by @gakonst in #599
  • feat(client): top up and close session channels over MCP by @gakonst in #600
  • fix(mcp): pay the next supported challenge when the preferred one fails by @gakonst in #602
  • fix(tempo): sign the cooperative close authorization on TIP-1034 closes by @gakonst in #603
  • ci: cut PR wall time from ~6.5 to ~2.5 minutes by @brendanjryan in #604
  • ci: pin changelogs to the locked install fix by @brendanjryan in #605
  • ci: per-partition feature caches, start the localnet early by @gakonst in #606
  • fix(fuzz): drop serde_json's reserved keys from generated JSON by @brendanjryan in #607
  • chore(ci): replace archived Tempo lints with standard checks by @decofe in #612
  • fix(core): bound Authorization values at 64 KiB before extraction (mppx#1034) by @brendanjryan in #611
  • fix: Bind Tempo proof realms to HTTP hosts by @decofe in #610
  • fix(fuzz): use the 64 KiB authorization limit in fuzz_authorization (mppx#1034) by @brendanjryan in #613
  • feat(server): verify TIP-1034 precompile sessions by @gakonst in #637
  • feat(tower): add opt-in Problem Details response bodies by @brendanjryan in #638
  • feat(server): add method-specific expected-request binding by @brendanjryan in #639
  • chore: accept contributions through issues only by @brendanjryan in #640
  • fix(tempo): re-check challenge expiry before broadcast (mppx#1078) by @brendanjryan in #636
  • fix(stripe): reject unbound externalId as invalid-challenge (mpp-tools#94) by @brendanjryan in #641
  • fix(axum): verify framework scope in default ChargeChallenger methods (AGR-2026-110) by @brendanjryan in #614
  • fix(tempo): use expiring nonces for session close transactions (mppx#864) by @brendanjryan in #618
  • feat(tempo): answer replayed charge credentials with 403 (mppx#1039) by @brendanjryan in #627
  • fix(tempo): pay MACH charge gas in a stablecoin (mppx#843) by @brendanjryan in #616
  • fix(tempo): stop charging a channel with a pending close request by @brendanjryan in #644
  • fix(server): dispatch composed credentials to the issuing route (mppx#936) by @brendanjryan in #619
  • feat(server): expose the verified payer on payment success (mppx#1038) by @brendanjryan in #628
  • feat(tempo): add currency allowlist and per-charge caps to TempoProvider (mppx#1035) by @brendanjryan in #629
  • fix(client): report unknown payment outcome when the paid retry returns 5xx (mppx#1043) by @brendanjryan in #631
  • feat(client): add a redirect-safe charge client by @brendanjryan in #645
  • feat(tempo): check live escrow before metered stream charges (mppx#1052) by @brendanjryan in #634
  • feat(server): answer bare 402 challenges with payment-required problem details by @brendanjryan in #643
  • perf(tempo): read on-chain channel concurrently with the stored channel on vouchers (mppx#1061) by @brendanjryan in #635
  • fix(tempo): serialize session funding decisions (mppx#1050) by @brendanjryan in #632
  • fix(tempo): answer settled hash replays with 403 again by @brendanjryan in #646
  • fix(tempo): require remaining validity for sponsored transactions (mppx#1029) by @brendanjryan in #626
  • fix(tempo): recover confirmed charges after broadcast RPC errors (mppx#1028) by @brendanjryan in #625
  • fix(tempo): bound session management requests (mppx#1053) by @brendanjryan in #633
  • feat(tempo): report receipt funding currency (mppx#915) by @brendanjryan in #620
  • fix(tempo): apply expected chain pins to Accounts sessions (mppx#961) by @brendanjryan in #622
  • ci: release weekly on mondays via scheduled auto-merge by @brendanjryan in #642
  • ci: close PRs after 14 days of inactivity by @brendanjryan in #647
  • fix(tempo): require opt-in for sponsored access keys (mppx#973) by @brendanjryan in #624
  • fix(ws): bound inbound session payment frames (mppx#968) by @brendanjryan in #623
  • feat(stripe): standardize PaymentIntent analytics metadata (mppx#860) by @brendanjryan in #617
  • fix(proxy): strip payment headers from upstream responses (mppx#947) by @brendanjryan in #621
  • fix(stripe): remove obsolete MPP metadata (mppx#816) by @brendanjryan in #615
  • fix(tempo): cap charge validBefore at the second after challenge expiry (mppx#1042) by @brendanjryan in #630
  • Release v0.17.0 by @tempo-github-sts[bot] in #601

Full Changelog: v0.16.0...v0.17.0