Docs Navigationexpand_more

Quickstart

Quickstart: Gas Abstraction (EIP-7710)

Run a minimal gas-sponsorship flow through the public relayer.

Recommended first step: load the skill

For best results, install and use the public-relayer skill before implementing this quickstart. It includes proven guidance for capability discovery, fee quote locking, delegation payloads, and status tracking.

Install skill

npx skills add 1Shot-API/skills/public-relayer

Why Use the 1Shot Public Relayer

The 1Shot public relayer provides intent execution infrastructure with gas abstraction in a single permissionless solution with no signup, no business account, and no tier-managed overhead. You can integrate directly over JSON-RPC and ship immediately.

To pay for execution, include a stablecoin transfer in the submitted bundle using one of the relayer's accepted tokens. If the fee token sits on a different network than the work transaction, you can pay gas on one chain and still execute work on the target chain. The 1Shot relayer gives you a stable, highly-available delegate address to grant execution permissions to so your app or agent doesn't have to manage its own delegate key just to handle intents.

The relayer is built for enterprise-scale traffic, so when usage spikes you don't need to upgrade plans or pre-fund infrastructure like a paymaster. 1Shot handles operational capacity so your team can focus on product growth.

What you need before starting

  • A target chain supported by the relayer and an accepted ERC-20 payment token for that chain.
  • A signer that can produce EIP-7702 authorization and delegation signatures (commonly via @metamask/smart-accounts-kit).
  • A transaction intent to execute (token transfer, app action, or contract call) and a rough gas estimate.
  • A webhook endpoint (destinationUrl) if you want near real-time status updates without polling.

Lifecycle

The end-to-end flow from account authorization to confirmed relay status.

1

Authorize smart-account upgrade if needed

EVM Account
Local
Sign EIP-7702 authorization for a stateless delegator smart account.
2

Sign delegation and fee scope

EVM Account
USDCUSDC
USDTUSDT
USDGUSDG
Local
Sign delegation/caveats for fee payment and the target onchain execution.
3

Submit to the public relayer

EVM Account
1Shot Public Relayer
POST payload: delegation context, encoded transactions, optional: 7702 authorization + destinationUrl.
4

Track lifecycle status

EVM Account / App Backend
Webhook
Polling
1Shot Public Relayer
Webhook status updates to your destinationUrl.
Poll relayer_getStatus until terminal state.

Step 1: Discover relayer capabilities

Call relayer_getCapabilities first. Use this response as source-of-truth for chain support, accepted payment tokens, feeCollector, and targetAddress.

  • Do not hardcode payment tokens; pick from the returned token list for the selected chain.
  • Use the returned targetAddress as the delegation to address. If this does not match, redemption will fail.
  • Cache capabilities for the session and refresh periodically.

Query supported networks and tokens

curl -X POST "https://relayer.1shotapi.com/relayers" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"relayer_getCapabilities","params":["1"]}' | jq

Step 2 (Option A): Quote fee and lock context

Use relayer_getFeeData when the delegation bundle is **not built yet** — for example, to show a rough fee in browser permission UX before the user signs.

Call relayer_getFeeData with (chainId, paymentToken).

This returns gasPrice, rate, minFee, expiry, and context. Pass the exact context into your send call to lock the quote during its validity window.

  • Estimate execution gas and convert native gas cost to payment-token amount using rate.
  • Apply the floor: feeAmount = max(convertedFee, minFee).
  • Treat quotes past expiry as stale and fetch a fresh quote before signing/submitting.

Quote network fee (price lock)

curl -X POST "https://relayer.1shotapi.com/relayers" -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"relayer_getFeeData","params":{"chainId":"8453","token":"<select-token>"}}' | jq

Step 2 (Option B): Estimate fee from a signed bundle

Once the send bundle is assembled (Step 3), call the matching estimate method **immediately before submission**. Use the same params shape as send; omit context. Optional taskId, destinationUrl, and memo are ignored for pricing.

Prefer the estimate context over Step 2 (Option A) relayer_getFeeData when the signed bundle exists. Reserve Step 2 (Option A) for pre-bundle rough quotes only.

  • Same chain fee + work execution → relayer_estimate7710Transaction.
  • Fee on chain A and work on chain B (or atomic multi-chain batch) → relayer_estimate7710TransactionMultichain.
  • success — check before send; validation and simulation failures return error in the result body (not always a JSON-RPC error).
  • requiredPaymentAmount — fee in payment-token atoms, floored at chain/token minFee.
  • gasUsed — map of chain id → summed gas units (decimal strings).
  • context — signed price-lock quote for single-chain send; pass as params.context on send.
  • contextByChainId — per-chain signed quotes for multichain send; set params[i].context = contextByChainId[params[i].chainId].
  1. POST estimate with the current bundle (mock fee execution ≥ minFee).
  2. If success === false, fix the bundle from error (missing payment, below minFee, simulation revert, invalid delegation).
  3. If requiredPaymentAmount differs from your mock fee, update the fee execution amount and delegation scope, then re-sign and re-estimate.
  4. Send immediately with the returned context / contextByChainId to lock the quote (~45 seconds).

Example: Estimate Gas Abstracted Token Send

Select a chain to load supported tokens.

Relayer endpoint: https://relayer.1shotapi.com/relayers

Estimate transaction fee

Connect, sign a delegation, and run estimate to generate the curl command.

Step 3: Build and send the transaction bundle

Use relayer_send7710Transaction for same-chain fee + execution, or relayer_send7710TransactionMultichain when fee payment and execution happen across chains.

  • Initialize a 7702StatelessDelegator smart account representation for the signer.
  • Browser EIP-7715 flow: the wallet handles EIP-7702 upgrade and authorization; do not add authorizationList to the relayer payload. Local/script signers may include one authorizationList entry on first use.
  • Create and sign a delegation scoped to required actions and amounts (fee transfer plus work call).
  • Submit transactions with permission context and encoded executions; include the signed context from Step 2 (Option B) estimate when available (result.context or result.contextByChainId[chainId]). Fall back to Step 2 (Option A) relayer_getFeeData only for pre-bundle rough quotes.
  • Prefer setting destinationUrl so relayer status is pushed to you instead of polled.

Example: One-time Gas Abstracted Token Send

Select a chain to load supported tokens.

Relayer endpoint: https://relayer.1shotapi.com/relayers

Gas relay transaction

Curl -X POST ...

Step 4: Track execution to terminal state

Submission returns TaskId (or TaskId[] for multichain). Track each task until terminal success/failure.

  • Preferred path: receive signed webhook events and verify Ed25519 signatures against relayer JWKS.
  • Polling fallback: call relayer_getStatus every 2-3 seconds and stop on terminal statuses.
  • Operational status shape: Pending/Submitted are non-terminal; Confirmed/Rejected/Reverted are terminal.

Relayer endpoint: https://relayer.1shotapi.com/relayers

Query relay status

Enter a TaskId to generate the curl command.

Implementation checklist

  • Always use fresh delegation salt values to avoid replay collisions.
  • Serialize bigint/byte values to JSON-safe hex before sending JSON-RPC payloads.
  • Scope permissions narrowly (amount, token, target function) and avoid overbroad allowances.
  • Use webhooks in production for scale, and verify each event signature before accepting state transitions.
  • Log task IDs and terminal outcomes with enough context for support/debugging.

Use the skill to accelerate implementation

  • Install: npx skills add 1Shot-API/skills/public-relayer
  • Prompt your coding agent with concrete outcomes: capabilities fetch, fee lock flow, signed send call, and webhook verification.
  • For non-custodial client wallets, combine with webauthn-prf-wallet and keep key material isolated in an iframe boundary.