> ## Documentation Index
> Fetch the complete documentation index at: https://docs.chainstack.com/llms.txt
> Use this file to discover all available pages before exploring further.

# eth_simulateV1 | Hyperliquid EVM

> The eth_simulateV1 JSON-RPC method provides transaction simulation capabilities on the Hyperliquid EVM blockchain. On Hyperliquid EVM.

<Info>
  This method is available on Chainstack. Not all Hyperliquid methods are available on Chainstack, as the open-source node implementation does not support them yet — see [Hyperliquid methods](/docs/hyperliquid-methods) for the full availability breakdown.
</Info>

The `eth_simulateV1` JSON-RPC method provides transaction simulation capabilities on the Hyperliquid EVM blockchain. This method allows developers to execute transactions in a controlled environment without actually submitting them to the blockchain, enabling testing, gas estimation, and outcome prediction.

<Check>
  **Get your own node endpoint today**

  [Start for free](https://console.chainstack.com/) and get your app to production levels immediately. No credit card required.

  You can sign up with your GitHub, X, Google, or Microsoft account.
</Check>

## Parameters

The method accepts a single parameter object containing simulation configuration:

### Simulation parameters

* `blockStateCalls` (array, required) — Array of block state call objects
  * `calls` (array, required) — Array of transaction calls to simulate
    * `from` (string, optional) — Transaction sender address
    * `to` (string, optional) — Transaction recipient address
    * `gas` (string, optional) — Gas limit as hexadecimal string
    * `gasPrice` (string, optional) — Gas price as hexadecimal string
    * `value` (string, optional) — Transaction value as hexadecimal string
    * `data` (string, optional) — Transaction data as hexadecimal string
  * `blockOverride` (object, optional) — Block state override options
    * `number` (string) — Block number to simulate against (e.g., "latest")
* `traceTransfers` (boolean, optional) — Whether to trace token transfers during simulation
* `validation` (boolean, optional) — Whether to perform validation during simulation

## Response

The method returns detailed simulation results including transaction outcomes, gas usage, and state changes.

### Response structure

**Simulation results:**

* `result` — Object containing simulation outcome data including gas estimates, transaction success status, and any error messages

**Transaction simulation details:**

* Gas consumption estimates and limits
* Transaction success or failure status
* State changes and side effects
* Error messages if simulation fails
* Transfer traces if enabled

## Usage example

### Basic transaction simulation

```javascript theme={"system"}
// Simulate a simple value transfer
const simulateTransaction = async () => {
  const response = await fetch('https://hyperliquid-mainnet.core.chainstack.com/YOUR_ENDPOINT/evm', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'eth_simulateV1',
      params: [{
        blockStateCalls: [{
          calls: [{
            from: "0x69835D480110e4919B7899f465aAB101e21c8A87",
            to: "0xb4DcFE4590adBd275aC3Ef1A3dd10e819d11648c",
            gas: "0x5208",
            gasPrice: "0x9184e72a000",
            value: "0xde0b6b3a7640000",
            data: "0x"
          }],
          blockOverride: {
            number: "latest"
          }
        }],
        traceTransfers: false,
        validation: true
      }],
      id: 1
    })
  });
  
  const data = await response.json();
  return data.result;
};

// Test transaction before sending
simulateTransaction().then(result => {
  console.log('Simulation result:', result);
  // Check if transaction would succeed before actually sending it
});
```

## Example request

```shell Shell theme={"system"}
curl -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_simulateV1",
    "params": [
      {
        "blockStateCalls": [
          {
            "calls": [
              {
                "from": "0x69835D480110e4919B7899f465aAB101e21c8A87",
                "to": "0xb4DcFE4590adBd275aC3Ef1A3dd10e819d11648c",
                "gas": "0x5208",
                "gasPrice": "0x9184e72a000",
                "value": "0xde0b6b3a7640000",
                "data": "0x"
              }
            ],
            "blockOverride": {
              "number": "latest"
            }
          }
        ],
        "traceTransfers": false,
        "validation": true
      }
    ],
    "id": 1
  }' \
  https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274/evm
```

## Use cases

The `eth_simulateV1` method is essential for applications that need to:

* **Transaction testing**: Test transactions before submitting them to avoid failed transactions and wasted gas
* **Gas estimation**: Accurately estimate gas requirements for complex transactions and smart contract interactions
* **Smart contract debugging**: Debug smart contract calls and identify potential issues before deployment
* **DeFi protocol integration**: Test complex DeFi transactions involving multiple protocols and token swaps
* **Transaction optimization**: Optimize transaction parameters and gas settings for better execution
* **Risk management**: Assess transaction risks and potential failures in trading and financial applications
* **MEV protection**: Simulate transactions to detect and prevent MEV (Maximum Extractable Value) attacks
* **Batch transaction planning**: Plan and validate batch transactions before execution
* **State change prediction**: Predict state changes and side effects of complex transactions
* **Cross-protocol interactions**: Test interactions between different protocols and smart contracts
* **Governance proposals**: Simulate governance proposals and their effects before voting
* **Arbitrage strategies**: Test arbitrage opportunities and validate profitability before execution
* **Liquidation simulations**: Test liquidation scenarios and validate liquidation bot strategies
* **Oracle integration**: Test oracle data integration and price feed reliability
* **Bridge operations**: Simulate cross-chain bridge operations and validate transfer logic
* **Staking mechanisms**: Test staking and unstaking operations with various parameters
* **Token distribution**: Simulate token distribution scenarios and validate allocation logic
* **Flash loan strategies**: Test flash loan strategies and validate repayment scenarios
* **AMM interactions**: Simulate automated market maker interactions and liquidity provision
* **NFT marketplace**: Test NFT trading scenarios and marketplace integrations

This method provides comprehensive transaction simulation capabilities, enabling developers to build robust and reliable applications on the Hyperliquid EVM platform with confidence in transaction outcomes.


## OpenAPI

````yaml /openapi/hyperliquid_node_api/evm_eth_simulate_v1.json post /evm
openapi: 3.0.0
info:
  title: Hyperliquid EVM API - eth_simulateV1
  version: 1.0.0
servers:
  - url: >-
      https://hyperliquid-mainnet.core.chainstack.com/4f8d8f4040bdacd1577bff8058438274
security: []
paths:
  /evm:
    post:
      summary: eth_simulateV1
      description: >-
        Simulates transactions without actually executing them on the
        blockchain. This method allows for testing transaction outcomes,
        estimating gas usage, and validating transaction logic before
        submission.
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - jsonrpc
                - method
                - params
                - id
              properties:
                jsonrpc:
                  type: string
                  enum:
                    - '2.0'
                  default: '2.0'
                  description: JSON-RPC version
                method:
                  type: string
                  enum:
                    - eth_simulateV1
                  default: eth_simulateV1
                  description: The RPC method name
                params:
                  type: array
                  minItems: 1
                  maxItems: 1
                  items:
                    type: object
                    required:
                      - blockStateCalls
                    properties:
                      blockStateCalls:
                        type: array
                        items:
                          type: object
                          required:
                            - calls
                          properties:
                            calls:
                              type: array
                              items:
                                type: object
                                properties:
                                  from:
                                    type: string
                                    description: Transaction sender address
                                  to:
                                    type: string
                                    description: Transaction recipient address
                                  gas:
                                    type: string
                                    description: Gas limit as hexadecimal string
                                  gasPrice:
                                    type: string
                                    description: Gas price as hexadecimal string
                                  value:
                                    type: string
                                    description: Transaction value as hexadecimal string
                                  data:
                                    type: string
                                    description: Transaction data as hexadecimal string
                            blockOverride:
                              type: object
                              properties:
                                number:
                                  type: string
                                  description: Block number to simulate against
                      traceTransfers:
                        type: boolean
                        description: Whether to trace token transfers during simulation
                      validation:
                        type: boolean
                        description: Whether to perform validation during simulation
                  default:
                    - blockStateCalls:
                        - calls:
                            - from: '0x69835D480110e4919B7899f465aAB101e21c8A87'
                              to: '0xb4DcFE4590adBd275aC3Ef1A3dd10e819d11648c'
                              gas: '0x5208'
                              gasPrice: '0x9184e72a000'
                              value: '0xde0b6b3a7640000'
                              data: 0x
                          blockOverride:
                            number: latest
                      traceTransfers: false
                      validation: true
                  description: Simulation parameters
                id:
                  type: integer
                  default: 1
                  description: Request identifier
            example:
              jsonrpc: '2.0'
              method: eth_simulateV1
              params:
                - blockStateCalls:
                    - calls:
                        - from: '0x69835D480110e4919B7899f465aAB101e21c8A87'
                          to: '0xb4DcFE4590adBd275aC3Ef1A3dd10e819d11648c'
                          gas: '0x5208'
                          gasPrice: '0x9184e72a000'
                          value: '0xde0b6b3a7640000'
                          data: 0x
                      blockOverride:
                        number: latest
                  traceTransfers: false
                  validation: true
              id: 1
      responses:
        '200':
          description: Successful response with simulation results
          content:
            application/json:
              schema:
                type: object
                properties:
                  jsonrpc:
                    type: string
                    description: JSON-RPC version
                  id:
                    type: integer
                    description: Request identifier
                  result:
                    type: object
                    description: >-
                      Simulation results including gas estimates and transaction
                      outcomes
              example:
                jsonrpc: '2.0'
                id: 1
                result: {}

````