Gelato Developer Docs

https://docs.gelato.cloud
Admin
Gelato provides a comprehensive suite of tools and services for building onchain applications,...
Tokens:112,167
Snippets:903
Trust Score:7.8
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup Smart Account with Viem

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/pay-with-native

Configure a smart account using Viem, compatible with the account abstraction standards. This example uses a Solady smart account implementation.

```typescript
const publicClient = createPublicClient({ chain: baseSepolia, transport: http() });
const signer = privateKeyToAccount(PRIVATE_KEY as any);

const account = await toSoladySmartAccount({
  client: publicClient,
  owner: signer,
});
```

--------------------------------

### Before: Smart Wallet SDK Migration Example

Source: https://docs.gelato.cloud/paymaster-%26-bundler/additional-resources/wallet-sdk

This snippet shows the setup and usage of the Gelato Smart Wallet SDK for sending transactions. It requires an API key and a private key for account management.

```typescript
import {
  createGelatoSmartWalletClient,
  type GelatoTaskStatus,
  sponsored,
} from "@gelatonetwork/smartwallet";
import {
  http,
  type Hex,
  createWalletClient,
  createPublicClient,
} from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { kernel } from "@gelatonetwork/smartwallet/accounts";
import { baseSepolia } from "viem/chains";

const API_KEY = process.env.GELATO_API_KEY as string;
const privateKey = process.env.PRIVATE_KEY as Hex;
const owner = privateKeyToAccount(privateKey);

const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

(async () => {
  // Create Kernel account with EIP-7702
  const account = await kernel({
    owner: owner,
    client: publicClient,
    eip7702: true,
  });

  console.log("Account address:", account.address);

  const client = createWalletClient({
    account,
    chain: baseSepolia,
    transport: http(),
  });

  const swc = await createGelatoSmartWalletClient(client, {
    apiKey: API_KEY,
  });

  // Prepare calls
  const preparedCalls = await swc.prepareCalls({
    payment: sponsored(),
    calls: [{
      to: "0xEEeBe2F778AA186e88dCf2FEb8f8231565769C27",
      data: "0xd09de08a", // increment()
      value: 0n,
    }],
  });

  // Send prepared calls
  const response = await swc.sendPreparedCalls({ preparedCalls });

  console.log(`Gelato ID: ${response.id}`);

  // Event-based status handling
  response.on("success", (status: GelatoTaskStatus) => {
    console.log(`Transaction hash: ${status.transactionHash}`);
    process.exit(0);
  });
  response.on("error", (error: Error) => {
    console.error(`Failed: ${error.message}`);
    process.exit(1);
  });
})();

```

--------------------------------

### After: Gasless SDK + ZeroDev Migration Example

Source: https://docs.gelato.cloud/paymaster-%26-bundler/additional-resources/wallet-sdk

This snippet demonstrates the setup and usage of the Gasless SDK with ZeroDev for sending gasless UserOperations. It requires a Gelato API key and uses ZeroDev's Kernel account creation.

```typescript
import { createGelatoBundlerClient } from "@gelatocloud/gasless";
import { createKernelAccount } from "@zerodev/sdk";
import { KERNEL_V3_3 } from "@zerodev/sdk/constants";
import { createPublicClient, type Hex, http } from "viem";
import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
import { baseSepolia } from "viem/chains";
import { entryPoint07Address } from "viem/account-abstraction";

const GELATO_API_KEY = process.env.GELATO_API_KEY as string;
const PRIVATE_KEY = process.env.PRIVATE_KEY as Hex;

(async () => {
  const owner = privateKeyToAccount(
    (PRIVATE_KEY ?? generatePrivateKey()) as Hex
  );

  console.log("EOA address:", owner.address);

  const client = createPublicClient({
    chain: baseSepolia,
    transport: http(),
  });

  // Create EIP-7702 Kernel Smart Account using ZeroDev SDK
  const account = await createKernelAccount(client, {
    entryPoint: {
      address: entryPoint07Address,
      version: "0.7",
    },
    kernelVersion: KERNEL_V3_3,
    eip7702Account: owner,
  });

  console.log("Kernel Smart Account (EIP-7702):", account.address);
  console.log("EIP-7702 enabled:", account.address === owner.address);

  // Create Gelato Bundler Client
  const bundler = await createGelatoBundlerClient({
    account,
    apiKey: GELATO_API_KEY,
    client,
  });

  // Get EIP-7702 authorization if needed (first transaction only)
  const authorization = await account.eip7702Authorization?.();

  if (authorization) {
    console.log("EOA needs authorization (not delegated yet)");
  } else {
    console.log("EOA already delegated to Kernel implementation");
  }

  console.log("Sending UserOperation...");

  // Send the user operation
  const hash = await bundler.sendUserOperation({
    calls: [{
      to: "0xEEeBe2F778AA186e88dCf2FEb8f8231565769C27",
      data: "0xd09de08a", // increment()
    }],
    authorization,
  });

  console.log(`User operation hash: ${hash}`);

  // Wait for receipt
  const { receipt } = await bundler.waitForUserOperationReceipt({ hash });

  console.log(`Transaction hash: ${receipt.transactionHash}`);
})();

```

--------------------------------

### Install Permissionless and Viem

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/sponsor-gas-with-gastank

Install the necessary packages for building permissionless applications with Viem.

```bash
npm install permissionless viem
```

```bash
yarn add permissionless viem
```

```bash
pnpm add permissionless viem
```

--------------------------------

### Install Dependencies for Turnkey Integration

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Install the necessary packages for integrating Gelato's gasless functionality with Turnkey.

```bash
npm install @gelatocloud/gasless @turnkey/sdk-browser @turnkey/viem viem
```

--------------------------------

### Setup Smart Account with viem

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/estimate-gas

Configure a viem public client and create a smart account using a private key. This is the initial setup for interacting with the bundler.

```typescript
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http()
});

const signer = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);

const account = await toSoladySmartAccount({
  client: publicClient,
  owner: signer,
});
```

--------------------------------

### Install Dependencies for Web3Auth Integration

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Install the necessary packages for integrating Gelato's gasless functionality with Web3Auth.

```bash
npm install @gelatocloud/gasless @web3auth/modal @web3auth/ethereum-provider viem
```

--------------------------------

### Install Viem for Gas Sponsorship

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/sponsor-gas-with-gastank

Install the Viem library if you plan to use it for gas sponsorship without the Gelato Gasless SDK. This is a prerequisite for the Viem implementation.

```bash
npm install viem
```

```bash
yarn add viem
```

```bash
pnpm add viem
```

--------------------------------

### Install Dependencies for Dynamic Embedded Wallets

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Install the necessary packages for integrating Gelato Gasless SDK with Dynamic embedded wallets.

```bash
npm install @gelatocloud/gasless @dynamic-labs/sdk-react-core @dynamic-labs/ethereum @dynamic-labs/wagmi-connector @tanstack/react-query wagmi viem
```

--------------------------------

### Install Gelato Gasless SDK

Source: https://docs.gelato.cloud/gasless-with-relay/gasless-transactions-evm/implementation-paths

Install the Gelato Gasless SDK using npm. This is the first step for integrating gasless transactions via the SDK.

```bash
npm install @gelatocloud/gasless
```

--------------------------------

### Install OpenZeppelin Contracts

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/meta-tx

Install the OpenZeppelin Contracts library, which is required for the ECDSA utility used in the meta-transaction contract.

```bash
npm install @openzeppelin/contracts
```

--------------------------------

### Update Dependencies: Uninstall Old, Install New

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

Remove the existing Relay SDK package and install the new Gasless SDK along with viem.

```bash
# Remove old SDK
npm uninstall @gelatonetwork/relay-sdk

# Install new SDK
npm install @gelatocloud/gasless viem
```

--------------------------------

### Install Dependencies for Privy Embedded Wallets

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Install the necessary packages for integrating Gelato Gasless SDK with Privy embedded wallets.

```bash
npm install @gelatocloud/gasless @privy-io/react-auth @privy-io/wagmi @tanstack/react-query viem
```

--------------------------------

### Install Dependencies for Gelato Gasless

Source: https://docs.gelato.cloud/gasless-with-relay/gelato-turbo-relayer/quick-start

Install the necessary packages for Gelato gasless transactions using npm, yarn, or pnpm.

```bash
npm install @gelatocloud/gasless viem
```

```bash
yarn add @gelatocloud/gasless viem
```

```bash
pnpm add @gelatocloud/gasless viem
```

--------------------------------

### Setup Gelato Smart Account

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/batching-transactions

Initialize a Gelato Smart Account using a private key for ownership and a viem public client configured for the desired chain.

```typescript
const owner = privateKeyToAccount(
  (process.env.PRIVATE_KEY ?? generatePrivateKey()) as Hex
);

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

const account = toGelatoSmartAccount({
  client,
  owner,
});
```

--------------------------------

### Complete Migration Example: Before (Relay SDK)

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

Demonstrates the usage of the legacy Gelato Relay SDK for sponsoring a transaction. Includes manual polling for task status.

```typescript
import { GelatoRelay, SponsoredCallRequest } from "@gelatonetwork/relay-sdk";
import { ethers } from "ethers";

const relay = new GelatoRelay();

const COUNTER_ADDRESS = "0xEEeBe2F778AA186e88dCf2FEb8f8231565769C27";
const SPONSOR_API_KEY = process.env.SPONSOR_API_KEY;

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

const abi = ["function increment()"];
const contract = new ethers.Contract(COUNTER_ADDRESS, abi, signer);
const { data } = await contract.increment.populateTransaction();

const request: SponsoredCallRequest = {
  chainId: (await provider.getNetwork()).chainId,
  target: COUNTER_ADDRESS,
  data: data,
};

const relayResponse = await relay.sponsoredCall(request, SPONSOR_API_KEY);
console.log(`Task ID: ${relayResponse.taskId}`);

// Manual polling for status
const interval = setInterval(async () => {
  const status = await relay.getTaskStatus(relayResponse.taskId);
  if (status?.taskState === "ExecSuccess") {
    console.log(`Transaction hash: ${status.transactionHash}`);
    clearInterval(interval);
  }
}, 2000);
```

--------------------------------

### Update Sponsored Call: Gasless SDK Example

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

Demonstrates making a transaction with the Gasless SDK, using `viem` for encoding and sending the transaction.

```typescript
import { createGelatoEvmRelayerClient } from "@gelatocloud/gasless";
import { encodeFunctionData } from "viem";
import { baseSepolia } from "viem/chains";

const relayer = createGelatoEvmRelayerClient({
  apiKey: process.env.GELATO_API_KEY,
});

const data = encodeFunctionData({
  abi: [{ name: "increment", type: "function", inputs: [], outputs: [] }],
  functionName: "increment",
});

const id = await relayer.sendTransaction({
  chainId: baseSepolia.id,
  to: targetAddress,
  data: data,
});

console.log(`Task ID: ${id}`);

try {
  const receipt = await relayer.waitForReceipt({ id });
  console.log(`Transaction hash: ${receipt.transactionHash}`);
} catch (error) {
  console.log(`Transaction failed: ${error.message}`);
}
```

--------------------------------

### Update Dependencies with npm

Source: https://docs.gelato.cloud/paymaster-%26-bundler/additional-resources/wallet-sdk

Uninstall the old SDK and install the new packages for Gasless, ZeroDev, and Viem.

```bash
# Remove old SDK
npm uninstall @gelatonetwork/smartwallet

# Install new SDKs
npm install @gelatocloud/gasless @zerodev/sdk viem
```

--------------------------------

### Check Software Dependencies

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

Verify that the necessary software dependencies are installed and meet the version requirements. These commands check the installed versions of git, go, node, just, foundry, and make.

```bash
`git --version`
```

```bash
`go version`
```

```bash
`node --version`
```

```bash
`just --version`
```

```bash
`forge --version`
```

```bash
`make --version`
```

--------------------------------

### Run the op-geth Node

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

Execute the initialization script and then run the op-geth node. Ensure the .env file is sourced to load environment variables.

```bash
cd /path/to/op-rollup-node/op-geth

# Load environment variables from the .env file in the root directory
source .env

# Initialize geth
./init-geth.sh

# Run the geth command with the environment variables
./build/bin/geth
```

--------------------------------

### Complete Migration Example: After (Gasless SDK)

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

Shows how to use the new Gasless SDK for sponsoring a transaction. It utilizes viem for encoding function data and includes built-in waiting for transaction receipts.

```typescript
import { createGelatoEvmRelayerClient } from "@gelatocloud/gasless";
import { encodeFunctionData } from "viem";
import { baseSepolia } from "viem/chains";

const COUNTER_ADDRESS = "0xEEeBe2F778AA186e88dCf2FEb8f8231565769C27";

const relayer = createGelatoEvmRelayerClient({
  apiKey: process.env.GELATO_API_KEY,
});

const data = encodeFunctionData({
  abi: [{ name: "increment", type: "function", inputs: [], outputs: [] }],
  functionName: "increment",
});

const id = await relayer.sendTransaction({
  chainId: baseSepolia.id,
  to: COUNTER_ADDRESS,
  data: data,
});

console.log(`Task ID: ${id}`);

// Built-in receipt waiting
try {
  const receipt = await relayer.waitForReceipt({ id });
  console.log(`Transaction hash: ${receipt.transactionHash}`);
} catch (error) {
  console.log(`Transaction failed: ${error.message}`);
}
```

--------------------------------

### Create Smart Account Client

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/pay-with-erc20-tokens/pay-with-erc20

Initialize a smart account client using viem and permissionless. Ensure you have your private key and the correct chain configuration.

```typescript
import { createSmartAccountClient } from "permissionless";
import { createPimlicoClient } from "permissionless/clients/pimlico";
import { prepareUserOperationForErc20Paymaster } from "permissionless/actions/erc20";
import { createPublicClient, http, type Hex } from "viem";
import { entryPoint07Address, toSoladySmartAccount } from "viem/account-abstraction";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const owner = privateKeyToAccount(process.env.PRIVATE_KEY as Hex);

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

const account = await toSoladySmartAccount({
  client,
  owner,
});
```

--------------------------------

### Build op-geth

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

Compile the op-geth binary using the make command.

```bash
make geth
```

--------------------------------

### Deprecated Relay SDK sponsoredCall Example

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

This example demonstrates the usage of the deprecated `sponsoredCall` method from the `@gelatonetwork/relay-sdk`. It is no longer supported and will not work.

```typescript
// DEPRECATED - Will no longer work
import { GelatoRelay, SponsoredCallRequest } from "@gelatonetwork/relay-sdk";

const relay = new GelatoRelay();

const request: SponsoredCallRequest = {
  chainId: 84532n,
  target: contractAddress,
  data: encodedData,
};

const relayResponse = await relay.sponsoredCall(request, SPONSOR_API_KEY);

```

--------------------------------

### Create Smart Account

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/sponsor-gas-with-gastank

Set up a smart account using your private key and a public client for the specified chain.

```typescript
import { createSmartAccountClient } from "permissionless";
import { createPublicClient, http } from "viem";
import { createBundlerClient, toSoladySmartAccount } from "viem/account-abstraction";
import { privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const owner = privateKeyToAccount(process.env.PRIVATE_KEY);

const client = createPublicClient({
  chain: baseSepolia,
  transport: http(),
});

const account = await toSoladySmartAccount({
  client,
  owner,
});
```

--------------------------------

### Set Up Environment Variables for Dynamic

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Configure your Dynamic app ID and Gelato API key as environment variables.

```bash
NEXT_PUBLIC_DYNAMIC_APP_ID=your_dynamic_environment_id
NEXT_PUBLIC_GELATO_API_KEY=your_gelato_api_key
```

--------------------------------

### Update Sponsored Call: Relay SDK Example

Source: https://docs.gelato.cloud/gasless-with-relay/additional-resources/migration-to-turbo-relayer/relay-sdk

This example shows how to make a sponsored call using the older Relay SDK, including contract interaction and request formatting.

```typescript
import { GelatoRelay, SponsoredCallRequest } from "@gelatonetwork/relay-sdk";
import { ethers } from "ethers";

const relay = new GelatoRelay();

const provider = new ethers.BrowserProvider(window.ethereum);
const signer = await provider.getSigner();

const contract = new ethers.Contract(targetAddress, abi, signer);
const { data } = await contract.increment.populateTransaction();

const request: SponsoredCallRequest = {
  chainId: (await provider.getNetwork()).chainId,
  target: targetAddress,
  data: data,
};

const relayResponse = await relay.sponsoredCall(request, SPONSOR_API_KEY);
console.log(`Task ID: ${relayResponse.taskId}`);
```

--------------------------------

### Gas Tank Balance Response

Source: https://docs.gelato.cloud/paymaster-%26-bundler/gastank/gastank-alerts

This is an example of the JSON response you will receive when querying your Gas Tank balance.

```json
{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "balance": "175028009",
    "decimals": 6,
    "unit": "usd"
  }
}
```

--------------------------------

### Initialize Turnkey for Embedded Wallets

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Set up the Turnkey SDK for browser use, preparing for wallet creation and interaction. This requires organization ID and Gelato API key.

```typescript
import { Turnkey } from "@turnkey/sdk-browser";
import { createAccount } from "@turnkey/viem";
import { createWalletClient, http } from "viem";
import { baseSepolia } from "viem/chains";


```

--------------------------------

### Successful Gas Estimation Response

Source: https://docs.gelato.cloud/paymaster-%26-bundler/bundler-api-endpoints/bundlers/eth_estimateuseroperationgas

This is an example of a successful response from the eth_estimateUserOperationGas endpoint, detailing the estimated gas limits.

```json
{
  "id": 1,
  "jsonrpc": "2.0",
  "result": {
    "preVerificationGas": "0x0",
    "verificationGasLimit": "0x148a6",
    "callGasLimit": "0x358e"
  }
}
```

--------------------------------

### Checkout Required Release Tag

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

Switch to the specific release tag of the Optimism monorepo required for compatibility with your setup.

```bash
git checkout ddc37daa49558c2fb5c1a92e694eeb7de5942e00
```

--------------------------------

### Configure OP Node Environment Variables

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

Set up the .env file with essential configurations for the OP node, including RPC endpoints, JWT paths, and P2P settings. Ensure P2P ports are externally accessible and static peers are configured.

```bash
OP_NODE_L1_ETH_RPC="<L1_RPC>"
OP_NODE_L1_RPC_KIND="standard"
OP_NODE_L2_ENGINE_AUTH="<JWT_FILE_PATH>"
OP_NODE_ROLLUP_LOAD_PROTOCOL_VERSIONS="true"
OP_NODE_ROLLUP_HALT="major"
OP_NODE_ROLLUP_CONFIG="<ROLLUP_JSON_PATH>"
OP_NODE_SEQUENCER_ENABLED="false"
OP_NODE_SEQUENCER_L1_CONFS="5"
OP_NODE_VERIFIER_L1_CONFS="4"
OP_NODE_LOG_FORMAT="json"
OP_NODE_LOG_LEVEL="info"
OP_NODE_P2P_DISABLE="false"
OP_NODE_P2P_LISTEN_IP="0.0.0.0"
OP_NODE_P2P_LISTEN_TCP_PORT="<P2P_TCP_PORT>"
OP_NODE_P2P_LISTEN_UDP_PORT="<P2P_UDP_PORT>"
OP_NODE_P2P_PEER_SCORING="none"
OP_NODE_P2P_PEER_BANNING="false"
OP_NODE_P2P_PEER_BANNING_DURATION="0h1m0s"
OP_NODE_P2P_BOOTNODES="<BOOTNODE_ENR>"
OP_NODE_P2P_ADVERTISE_TCP="<EXTERNAL_P2P_TCP_PORT>"
OP_NODE_P2P_ADVERTISE_UDP="<EXTERNAL_P2P_UDP_PORT>"
OP_NODE_P2P_ADVERTISE_IP="<EXTERNAL_P2P_IP>"
OP_NODE_P2P_SYNC_REQ_RESP="true"
OP_NODE_P2P_STATIC="<STATIC_PEERS>"
OP_NODE_P2P_PRIV_RAW="<P2P_NODE_PRIVATE_KEY>"
OP_NODE_RPC_ADDR="0.0.0.0"
OP_NODE_RPC_PORT="<ROLLUP_RPC_PORT>"
OP_NODE_RPC_ENABLE_ADMIN="true"
OP_NODE_SNAPSHOT_LOG="<SNAPSHOT_LOG_PATH>"
OP_NODE_METRICS_ENABLED="true"
OP_NODE_METRICS_ADDR="0.0.0.0"
OP_NODE_METRICS_PORT="<METRICS_PORT>"
OP_NODE_PPROF_ENABLED="true"
OP_NODE_L1_BEACON="<L1_BEACCON_API_URL>"
OP_NODE_L2_ENGINE_RPC="<GETH_ENGINE_RPC_URL>"
```

--------------------------------

### Generate Transaction Data

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/sponsoredcalls/overview

Encode the function call data for your target contract. This example encodes a call to an 'increment' function.

```typescript
import { encodeFunctionData } from 'viem';

const data = encodeFunctionData({
  abi: [{ name: 'increment', type: 'function', inputs: [], outputs: [] }],
  functionName: 'increment'
});
```

--------------------------------

### Setup EIP-712 Types and Domain

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/meta-tx

Define the EIP-712 types and domain for your meta-transaction. This is crucial for correctly signing messages that will be relayed.

```typescript
import { pad, toHex, type Hex } from 'viem';

const types = {
  MetaTransaction: [
    { name: 'nonce', type: 'uint256' },
    { name: 'from', type: 'address' },
    { name: 'functionSignature', type: 'bytes' },
  ],
} as const;

const domain = {
  name: 'SimpleCounter',
  version: '1',
  verifyingContract: simpleCounterAddress as Hex,
  salt: pad(toHex(chainId), { size: 32 }),
};
```

--------------------------------

### Create Smart Account with Permissionless

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/pay-with-native

Create a smart account using the `toKernelSmartAccount` function from permissionless. Requires an owner account, public client, and entry point configuration.

```typescript
const owner = privateKeyToAccount(process.env.PRIVATE_KEY);

        const publicClient = createPublicClient({
          chain: baseSepolia,
          transport: http(),
        });

        const account = await toKernelSmartAccount({
          client: publicClient,
          owners: [owner],
          entryPoint: {
            address: entryPoint07Address,
            version: "0.7",
          },
          version: "0.3.3",
        });
```

--------------------------------

### Example eth_chainId Response

Source: https://docs.gelato.cloud/rollup-as-a-service/how-to-guides/run-an-op-node

The expected JSON response when querying the eth_chainId method, indicating the node is running and its configured chain ID.

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": "0x2a88" // This is your chain id in hex, in this case its 10888
}
```

--------------------------------

### Create Gelato Smart Account

Source: https://docs.gelato.cloud/paymaster-%26-bundler/gelato-bundler-paymaster/quick-start

Set up the owner wallet and create a Gelato smart account using viem and Gelato's SDK. Ensure you have the necessary private key and chain configuration.

```typescript
import { createGelatoBundlerClient, toGelatoSmartAccount } from "@gelatocloud/gasless";
import { createPublicClient, http, type Hex } from "viem";
import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
import { baseSepolia } from "viem/chains";

const owner = privateKeyToAccount((process.env.PRIVATE_KEY ?? generatePrivateKey()) as Hex);

const client = createPublicClient({
  chain: baseSepolia,
  transport: http()
});

const account = await toGelatoSmartAccount({
  client,
  owner
});
```

--------------------------------

### Handling Status Codes in Code

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/tracking-gelato-request

Examples of how to handle the status codes returned by `relayer_getStatus` in both direct API calls and SDK usage.

```APIDOC
### Using Status Codes in Code

When using the SDK, `sendTransactionSync` returns the receipt directly and throws on failure:

```typescript
const receipt = await relayer.sendTransactionSync({ ... });
console.log(`Success! Hash: ${receipt.transactionHash}`);
```

When using the API directly, check against the numeric values:

```typescript
const data = await response.json();
const status = data.result.status;

// Terminal states
if (status === 200) {
  console.log('Transaction included');
} else if (status === 400) {
  console.log('Transaction rejected');
} else if (status === 500) {
  console.log('Transaction reverted');
}
// Non-terminal states (keep polling)
else if (status === 100 || status === 110) {
  console.log('Transaction pending...');
}
```
```

--------------------------------

### Create Gelato Bundler Client with Web3Auth

Source: https://docs.gelato.cloud/paymaster-%26-bundler/how-to-guides/embedded-wallets

Initialize the Gelato Bundler client using a viem wallet client connected to the Web3Auth provider. This example uses `permissionless` to create a Kernel smart account.

```typescript
import { createGelatoBundlerClient } from "@gelatocloud/gasless";
import { toKernelSmartAccount } from "permissionless/accounts";

const client = createWalletClient({
  chain: baseSepolia,
  transport: custom(provider),
});

const account = await toKernelSmartAccount({
  client,
  version: "0.3.1",
  entryPoint: {
      address: entryPoint07Address,
      version: "0.7"
  },
  owners: [client],
});

const bundler = await createGelatoBundlerClient({
  account,
  apiKey: process.env.NEXT_PUBLIC_GELATO_API_KEY as string,
  client,
  pollingInterval: 100,
});
```

--------------------------------

### Gelato Request Status API Response

Source: https://docs.gelato.cloud/gasless-with-relay/how-to-guides/tracking-gelato-request

Example JSON response from the `relayer_getStatus` endpoint, indicating the transaction status and receipt details.

```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "id": "0x0e670ec64341771606e55d6b4ca35a1a6b75ee3d5145a99d05921026d1527331",
    "status": 200,
    "message": "Transaction included",
    "receipt": {
      "transactionHash": "0x...",
      "blockNumber": 12345678,
      "gasUsed": "21000"
    }
  }
}
```
Tokens:
Raw