Skip to main content
Choose which providers receive your signed transactions while your application keeps one RPC URL. Reads, subscriptions and block recovery use the chain’s other providers. Use this to keep transactions out of the public mempool until inclusion. It needs RPC Core v0.8.0 or later.

​
Add transaction providers

Mount a profiles/ directory as described in Docker deployment, and put your provider URLs in .env. Save this as profiles/private-sends.yml:
Recreate the container so it picks up the new .env values, then check the configuration:
Point your application at http://localhost:4000/rpc/profile/private-sends/ethereum. The example profile fills this in with public relay endpoints. To confirm a send stayed inside the set, add ?include_meta=body to the URL. The response names the provider that received it and the policy that applied:

​
Choose a fallback

​
What stays visible

Private means out of the public mempool before inclusion. It doesn’t hide a transaction from everyone who handles it.
  • Relay operators and builders. Transaction providers and their downstream builders see every transaction sent to them, and can delay or drop it. Relay modes differ: some also share with every registered builder or with searchers. Read each operator’s documentation for the mode in your URL.
  • Calldata in simulations. eth_call and eth_estimateGas send calldata to a read provider, so simulating through Lasso shows that provider your intent before you sign. Simulate locally when that matters.
  • Hash polling. Polling a private transaction’s hash through a read provider ties the hash to your connection and timing. While the transaction is private, that provider returns null for it.
  • Timeouts. A timeout doesn’t prove a provider never received the bytes. A retry reaches another transaction provider, and each one is another recipient.
  • Wallets. A wallet that rebroadcasts through another endpoint bypasses the boundary.
  • After inclusion. A mined transaction is public.

​
Handle nonces

Ordinary providers exclude a private transaction from their pending nonce until inclusion, so manage nonces in your client. Lasso keeps no pending overlay.

​
Errors

After a failed eth_sendRawTransaction, Lasso looks up the hash among the providers of the phase that sent it, never outside it. The API reference has the full contract.

​
Limits

  • Each listed provider must exist on the chain and be able to send, with no duplicates, and at least one other provider must remain to serve reads.
  • The policy covers every send method, including relay-native and bundle methods, simulations of signed transactions, and unregistered methods whose params carry a signed transaction.
  • Lasso doesn’t forward caller headers such as X-Flashbots-Signature, so methods that need a sender signature header don’t work through it.
  • Background checks still reach transaction providers: the eth_chainId identity probe, and the newHeads head subscription when the provider has a ws_url. Neither carries transaction data. background_observations: false on the provider stops both.
  • The bundled public profile leaves transactions unset.

​
Next