Gasless Execution - Relay

How does it work?

Gasless transactions on EVM are regular transactions where the transaction signer and the gas payer are two different addresses. Rather than signing with the same address and then submitting their transaction and paying gas, a user can simply sign a transaction payload, and other entities (relayers, solvers, etc.) can submit the transaction on their behalf and sponsor the gas costs. This is not natively possible, so there are custom transaction payloads to enable this: Permit2, EIP-3009, ERC-2771 payloads, ERC-4337 user operations, etc. The core concept is that as long as the transaction execution does not rely on tx.origin (the transaction submitter), any user can sign permit payloads or Smart Account actions (EIP-7702, ERC-4337 user operations etc.) and a relayer can post those payloads on chain by wrapping them in a transaction. This is where the /execute API comes in. The API allows users to submit raw calls (the partial payload of a regular EVM transaction). It includes the to, data, value and an optional EIP-7702 authorizationList.

How to use it?

To use gasless execution you’ll need an API key with a linked funding address and a funded app balance. Create an API key in the Relay Dashboard, then see Fee Sponsorship for details on linking a funding address and funding your app balance.

Executing a gasless quote

In this example use case you want to execute a gasless Relay quote with the execute API.

  1. Get a quote
    This flow assumes that the user is using a smart wallet. Use the quote endpoint to get a quote for the transaction you want to execute. The originGasOverhead indicates how much additional gas overhead will be necessary to include the user operation on the chain as compared to a normal EOA transaction.

cURL 

curl -X POST "https://api.relay.link/quote/v2" \
-H "Content-Type: application/json" \
-d '{
  "user": "YOUR_WALLET_ADDRESS",
  "originChainId": 8453,
  "destinationChainId": 42161,
  "originCurrency": "0x0000000000000000000000000000000000000000",
  "destinationCurrency": "0x0000000000000000000000000000000000000000",
  "amount": "100000000000000",
  "tradeType": "EXACT_INPUT",
  "originGasOverhead": "300000" //This is the overhead gas cost of the smart wallet, this will be used when simulating the transaction
}'

Response 

{
  "steps": [
    {
      "id": "deposit",
      "action": "Confirm transaction in your wallet",
      "description": "Depositing funds to the relayer to execute the swap for ETH",
      "kind": "transaction",
      "items": [
        {
          "status": "incomplete",
          "data": {
            "from": "0x03508bB71268BBA25ECaCC8F620e01866650532c",
            "to": "0x4cd00e387622c35bddb9b4c962c136462338bc31",
            "data": "0x49290c1c00000000000000000000000003508bb71268bba25ecacc8f620e01866650532c70387ea00ba97925c3bf1263363b2a7bdc0401faa00f0af4140627c7f385952c",
            "value": "100000000000000",
            "chainId": 8453,
            "maxFeePerGas": "3501361",
            "maxPriorityFeePerGas": "1000007"
          },
          "check": {
            "endpoint": "/intents/status/v3?requestId=0xa9ad21ed31b40317d2dad7750d642b8a72adf086f250f8a33c1636488c780878",
            "method": "GET"
          }
        }
      ],
      "requestId": "0xa9ad21ed31b40317d2dad7750d642b8a72adf086f250f8a33c1636488c780878",
      "depositAddress": ""
    }
    // ...
  ],
  "fees": {
    "gas": {
      "currency": {
        "chainId": 8453,
        "address": "0x0000000000000000000000000000000000000000",
        "symbol": "ETH",
        "name": "Ether",
        "decimals": 18,
        "metadata": {
          "logoURI": "https://assets.relay.link/icons/1/light.png",
          "verified": true
        }
      },
      "amount": "89121108862",
      "amountFormatted": "0.000000089121108862",
      "amountUsd": "0.000279",
      "minimumAmount": "89121108862"
    },
    "relayer": {
      "currency": {
        "chainId": 8453,
        "address": "0x0000000000000000000000000000000000000000",
        "symbol": "ETH",
        "name": "Ether",
        "decimals": 18,
        "metadata": {
          "logoURI": "https://assets.relay.link/icons/1/light.png",
          "verified": true
        }
      },
      "amount": "9212128356056",
      "amountFormatted": "0.000009212128356056",
      "amountUsd": "0.028858",
      "minimumAmount": "9212128356056"
    }
  }
}
  1. Execute the transaction
    With the quote in hand, you can now execute the transaction. You’ll need to pass the data from previous steps to the API.
    const options = {
    method: 'POST',
    headers: {'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json'},
    body: JSON.stringify({
        requestId: steps[0].requestId, //Quote requestId from previous step
        executionKind: 'rawCalls',
        data: {
            chainId: 8453,
            to: 'YOUR_WALLET_ADDRESS',
            data: steps[0].items[0].data.data, //Quote data from previous step
            value: steps[0].items[0].data.value, //Quote value from previous step
        },
        executionOptions: {
            //Optional execution options
        }
    })
};

fetch('https://api.relay.link/execute', options) .then(res => res.json()) .then(res => console.log(res)) .catch(err => console.error(err));


3. **Monitor**  
Now that the transaction has been submitted, you can monitor the status of the transaction using the requestId from the quote data and the [status endpoint](https://docs.relay.link/references/api/get-intents-status-v3).
```javascript
const response = await fetch(`https://api.relay.link/intents/status/v3?requestId=${requestId}`);
const data = await response.json();
console.log(data);

Handling simulation errors

Relay simulates /execute raw calls before submission. If the simulation reverts, the API returns 400 with a decoded error label, a message, the requestId, and trace details when Relay can decode the revert path.

Response

{
  "error": "INVALID_SIGNATURE",
  "message": "Invalid signature",
  "requestId": "0x887091202256e66960493eb09c410188307cc734c919e89696b3ae9993a7fa1d",
  "details": {
    "topLevel": {
      "type": "CALL",
      "address": "0xca11bde05977b3631167028862be2a173976ca11",
      "contract": "Multicall3",
      "function": "Multicall3.aggregate3Value"
    },
    "innermost": {
      "type": "CALL",
      "address": "0x000000000022d473030f116ddee9f6b43ac78ba3",
      "contract": "Permit2",
      "selector": "0xda9c8680",
      "error": "execution reverted"
    },
    "path": [
      {
        "type": "CALL",
        "contract": "Multicall3",
        "function": "Multicall3.aggregate3Value"
      },
      {
        "type": "CALL",
        "contract": "Permit2",
        "selector": "0xda9c8680",
        "error": "execution reverted"
      }
    ],
    "revert": {
      "type": "customError",
      "label": "INVALID_SIGNATURE",
      "message": "Invalid signature",
      "selector": "0x8baa579f",
      "name": "InvalidSignature"
    }
  }
}

More Use Cases

Gasless ERC-20 transfer from ERC-4337 Smart Account

If the user has a Smart Account (such as an ERC-4337 Smart Account), any transaction can be made gasless for the Smart Account by signing an ERC-4337 user operation and submitting it to the /execute API. The only step is to create the user operation, get it signed by the user and then create the final call data of the handleOps call of the Entry Point before submitting to the /execute endpoint. Note: The maxFeePerGas and maxPriorityFeePerGas The ERC-4337 user operation should be 0; it will result in a double payment to the solver (The solver already has adjusted the cost in the quote, so no need for this payment)

Create the user operation

example.ts 

import {
    createPublicClient,
    createWalletClient,
    createClient,
    http,
    encodeFunctionData,
    keccak256,
    encodeAbiParameters,
    toHex,
} from "viem";
import { base } from "viem/chains";
import { UserOperation } from "./types.ts";
import { entryPointAbi, smartAccountAbi } from "./abis.ts";

// ---- Config ----
const ENTRY_POINT = "0xEntryPointAddress" as const;
const YOUR_WALLET_ADDRESS = "0xYourAddress" as const;
const BENEFICIARY = "0xYourBeneficiary" as const;

// ---- Clients ----
const publicClient = createPublicClient({
    chain: base,
    transport: http(),
});

const ownerAccount = ... // Replace with your owner account

const walletClient = createWalletClient({
    account: ownerAccount,
    chain: base,
    transport: http()
});

const userOpPackHash = keccak256(packUserOp(userOp));

const encoded = encodeAbiParameters(
    [
        { type: "bytes32" }, // userOp hash
        { type: "address" }, // entryPoint
        { type: "uint256" }, // chainId
    ],
    [userOpPackHash, ENTRY_POINT, BigInt(base.id)],
);

const userOpHash = keccak256(encoded);

const signature = await walletClient.signMessage({
    message: { raw: userOpHash },
});

const signedUserOp: UserOperation = { ...userOp, signature };

const handleOpsData = encodeFunctionData({
    abi: entryPointAbi,
    functionName: "handleOps",
    args: [[signedUserOp], BENEFICIARY],
});

Send the payload to the /execute endpoint

Request 

const options = {
    method: 'POST',
    headers: {'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json'},
    body: JSON.stringify({
        executionKind: 'rawCalls',
        data: {
            chainId: 8453,
            to: 'YOUR_WALLET_ADDRESS',
            data: handleOpsData,
            value: "0"
        }
    })
};

fetch('https://api.relay.link/execute', options)
    .then(res => res.json())
    .then(res => console.log(res))
    .catch(err => console.error(err));

Monitor

Now that the transaction has been submitted, you can monitor the status of the transaction using the requestId returned in the API response and the status endpoint.

const response = await fetch(`https://api.relay.link/intents/status/v3?requestId=${requestId}`);
const data = await response.json();
console.log(data);

Caveats