# eth\_signTransaction - Arbitrum

This method signs a transaction using the private key of the given account **without broadcasting.** This method requires the signing account to be **unlocked** or controlled by a wallet provider.

{% hint style="info" %}
This method requires the account to be **unlocked** on the node or handled by a wallet provider such as MetaMask.
{% endhint %}

#### Parameters

| Field                | Type   | Required | Description                                                                      |
| -------------------- | ------ | -------- | -------------------------------------------------------------------------------- |
| from                 | string | Yes      | The address signing the transaction. Must be unlocked or controlled by a wallet. |
| to                   | string | Yes      | Receiver address. Null if deploying a smart contract.                            |
| gas                  | string | no       | Gas limit for execution.                                                         |
| gasPrice             | string | no       | Gas price in wei.                                                                |
| maxPriorityFeePerGas | string | no       | EIP 1559 priority fee.                                                           |
| maxFeePerGas         | string | Yes      | EIP 1559 max total fee.                                                          |
| value                | string | Yes      | Amount of ETH sent, in wei. .                                                    |
| data                 | string | Yes      | Hex encoded input data for contract interaction. .                               |
| nonce                | string | Yes      | Nonce number for the transaction. .                                              |

#### Request

{% tabs %}
{% tab title="cURL" %}

```bash
curl --location 'https://go.getblock.us/<ACCESS_TOKEN>' \
--header 'Content-Type: application/json' \
--data '{
   "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "params": [
        {
            "from":  "0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd",
        
            "to": "0xd26ea0f03100358b2ebd4c9638f042aada9a1bcf",
            "gas": "0x76c0",
            "gasPrice": "0x9184e72a000",
            "nonce": "0x3c",
            "value": "0x9184e72a",
            "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
        }],
    "id": "getblock.io"
}'
```

{% endtab %}

{% tab title="Axios" %}

```javascript
import axios from 'axios'
let data = JSON.stringify({
    "jsonrpc": "2.0",
   "method": "eth_signTransaction",
    "params": [
        {
            "from":  "0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd",
        
            "to": "0xd26ea0f03100358b2ebd4c9638f042aada9a1bcf",
            "gas": "0x76c0",
            "gasPrice": "0x9184e72a000",
            "nonce": "0x3c",
            "value": "0x9184e72a",
            "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
}],
    "id": "getblock.io"
};

let config = {
  method: "post",
  maxBodyLength: Infinity,
  url: "https://go.getblock.us/<ACCESS_TOKEN>",
  headers: {
    "Content-Type": "application/json",
  },
  data: data,
};

axios
  .request(config)
  .then((response) => {
    console.log(JSON.stringify(response.data));
  })
  .catch((error) => {
    console.log(error);
  });

```

{% endtab %}

{% tab title="Request" %}

```python
import requests
import json

url = "https://go.getblock.us/<ACESS_TOKEN>"

payload = json.dumps({
   "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "params": [
        {
            "from":  "0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd",
        
            "to": "0xd26ea0f03100358b2ebd4c9638f042aada9a1bcf",
            "gas": "0x76c0",
            "gasPrice": "0x9184e72a000",
            "nonce": "0x3c",
            "value": "0x9184e72a",
            "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
}],
    "id": "getblock.io"
})
headers = {
  'Content-Type': 'application/json'
}

response = requests.request("POST", url, headers=headers, data=payload)

print(response.text)

```

{% endtab %}

{% tab title="Rust" %}

```rs
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = reqwest::Client::builder()
        .build()?;

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("Content-Type", "application/json".parse()?);

    let data = r#"{
   "jsonrpc": "2.0",
    "method": "eth_sign",
  "method": "eth_signTransaction",
    "params": [
        {
            "from":  "0xd1af2dac4e0a9d1f58b99e2f42bc0320ed74a7cd",
        
            "to": "0xd26ea0f03100358b2ebd4c9638f042aada9a1bcf",
            "gas": "0x76c0",
            "gasPrice": "0x9184e72a000",
            "nonce": "0x3c",
            "value": "0x9184e72a",
            "data": "0xd46e8dd67c5d32be8d46e8dd67c5d32be8058bb8eb970870f072445675058bb8eb970870f072445675"
}],
    "id": "getblock.io"
}"#;

    let json: serde_json::Value = serde_json::from_str(&data)?;

    let request = client.request(reqwest::Method::POST, "https://go.getblock.us/<ACCESS_TOKEN>")
        .headers(headers)
        .json(&json);

    let response = request.send().await?;
    let body = response.text().await?;

    println!("{}", body);

    Ok(())
}
```

{% endtab %}
{% endtabs %}

#### Response

```java
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "raw": "0xf86c808...",
    "tx": {
      "nonce": "0x0",
      "gas": "0x5208",
      "value": "0x0",
      "to": "0xE592427A0AEce92De3Edee1F18E0157C05861564",
      "from": "0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
    }
  }
}

```

#### Reponse Parameter Definition

| Field                   | Type           | Description                                                                    |
| ----------------------- | -------------- | ------------------------------------------------------------------------------ |
| raw                     | string         | Signed raw transaction in hex. Can be broadcast using eth\_sendRawTransaction. |
| tx.from                 | string         | Address that signed the transaction.                                           |
| tx.to                   | string or null | Recipient address or null for contract deployment.                             |
| tx.nonce                | string         | Nonce used for the transaction.                                                |
| tx.gas                  | string         | Gas limit.                                                                     |
| tx.gasPrice             | string         | Gas price in wei for legacy transactions.                                      |
| tx.maxPriorityFeePerGas | string         | Priority fee (EIP 1559).                                                       |
| tx.maxFeePerGas         | string         | Maximum total fee (EIP 1559).                                                  |
| tx.value                | string         | Amount of ETH sent in wei.                                                     |
| tx.data                 | string         | Encoded call data or contract bytecode.                                        |
| tx.chainId              | string         | Chain identifier for replay protection.                                        |
| tx.v                    | string         | Recovery ID used to verify the signature.                                      |
| tx.r                    | string         | First half of the signature.                                                   |
| tx.s                    | string         | Second half of the signature.                                                  |

#### Use case

The `eth_signTransaction` method helps developers to:

* Prepare transactions before broadcasting them
* Build cold wallet or multisig-style signing workflows
* Use relayers or batch processors that require signed payloads
* Enable advanced transaction flows where signing and sending occur separately
* Allow hardware wallets or custodial services to authorize a transaction before submission
* Support meta transaction systems and gas-sponsored flows

#### Error handling

| Status Code | Error Message   | Cause                                                                                                         |
| ----------- | --------------- | ------------------------------------------------------------------------------------------------------------- |
| 403         | Forbidden       | Missing or invalid ACCESS\_TOKEN.                                                                             |
| -3200       | Unknown account | <ul><li>Invalid account address</li><li>user rejected request</li><li>message must be hex or string</li></ul> |

#### Integration with Web3

The `eth_sign` method enables developers to:

* Sign transactions without broadcasting them
* Deliver signed raw transactions to relayers

{% tabs %}
{% tab title="Ethers.js" %}

```javascript
import { ethers } from "ethers";
const RPC_URL = "https://go.getblock.us/<ACCESS_TOKEN>";
const provider = new ethers.JsonRpcProvider(RPC_URL);
async function Call() {
  try {
     const result = await provider.send("eth_sign",
 [
    "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
    "0x48656c6c6f20576f726c64"
  ]);    
console.log("The result:", result);
    return result;
  } catch (error) {
    console.error("The error:", error);
    throw error;
  }
}
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.getblock.io/api-reference/arbitrum-arb/arbitrum_eth_signtransaction.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
