eth_signTransaction | Moonbase Alpha RPC Docs

Sign a transaction without broadcasting it on Moonbase Alpha. Public shared RPC endpoints commonly return deprecation, unsupported-method, or account-management errors because they do not keep unlocked signers.

Signs a transaction with the private key of the specified account on Moonbase Alpha without submitting it to the network.

Why Moonbase? Build on the Moonbeam testnet for risk-free EVM dApp development and deployment testing with free testnet tokens, full EVM compatibility, XCM testing capabilities, and identical feature set to Moonbeam mainnet.

Security Warning: Public Dwellir endpoints do not keep unlocked signers. On shared infrastructure, eth_signTransaction commonly returns a deprecation, unsupported-method, or account-management error instead of a signed payload. For production use, sign transactions client-side using libraries like ethers.js or web3.py, then broadcast with eth_sendRawTransaction.

When to Use This Method

eth_signTransaction is relevant for Moonbeam developers, dApp testers, and teams validating cross-chain integrations in limited scenarios:

Understanding the Signing Flow — Learn how transaction signing works before implementing client-side signing
Local Development — Sign transactions on a local dev node (Hardhat, Anvil, Ganache) where accounts are unlocked
Offline Signing Workflows — Generate signed transaction payloads for later broadcast

Request Parameters

Request

fromDATA (20 bytes)

Address of the account to sign with (must be unlocked)

toDATA (20 bytes)

Recipient address (omit for contract creation)

gasQUANTITY

Gas limit for the transaction (default: 90000)

gasPriceQUANTITY

Gas price in wei (legacy transactions)

valueQUANTITY

Value to send in wei

dataDATA

Compiled contract code or encoded method call

nonceQUANTITY

Transaction nonce (defaults to eth_getTransactionCount)

Response Body

Response

rawDATA

The RLP-encoded signed transaction, ready for eth_sendRawTransaction

txObject

The transaction object including v, r, s signature fields

{  "jsonrpc": "2.0",  "method": "eth_signTransaction",  "params": [    {      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",      "to": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",      "gas": "0x76c0",      "gasPrice": "0x9184e72a000",      "value": "0x9184e72a",      "data": "0x",      "nonce": "0x0"    }  ],  "id": 1}

{  "jsonrpc": "2.0",  "id": 1,  "result": {    "raw": "0xf86c808609184e72a0008276c094a94f5374fce5edbc8e2a8697c15331677e6ebf0b849184e72a801ba0fe38ca4e44a30002ac54af7cf922a6ac2ba11b7571d7c13e32e8ce2c6c8a...",    "tx": {      "nonce": "0x0",      "gasPrice": "0x9184e72a000",      "gas": "0x76c0",      "to": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",      "value": "0x9184e72a",      "input": "0x",      "v": "0x1b",      "r": "0xfe38ca4e44a30002ac54af7cf922a6ac2ba11b7571d7c13e32e8ce2c6c8a...",      "s": "0x3d850e0b25e3c7a3e4da3a7c1b1a4e3b5c6d7e8f9a0b1c2d3e4f5a6b7c8d9e..."    }  }}

Code Examples

Bash

# Local dev node only. Public Dwellir endpoints do not expose unlocked-account signing.
curl -X POST http://127.0.0.1:8545 \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_signTransaction",
    "params": [{
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x9184e72a",
      "nonce": "0x0"
    }],
    "id": 1
  }'

JavaScript

// Recommended: client-side signing with ethers.js
import { Wallet, JsonRpcProvider, parseEther } from 'ethers';

const provider = new JsonRpcProvider('https://moonbase-rpc.n.dwellir.com');
const wallet = new Wallet('YOUR_PRIVATE_KEY', provider);

const tx = {
  to: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
  value: parseEther('0.1'),
  gasLimit: 21000
};

// Sign without sending
const signedTx = await wallet.signTransaction(tx);
console.log('Signed Moonbase tx:', signedTx);

// Send later with eth_sendRawTransaction
const receipt = await provider.broadcastTransaction(signedTx);
console.log('Tx hash:', receipt.hash);

Python

from web3 import Web3
from eth_account import Account

w3 = Web3(Web3.HTTPProvider('https://moonbase-rpc.n.dwellir.com'))

# Recommended: client-side signing
account = Account.from_key('YOUR_PRIVATE_KEY')

tx = {
    'to': '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
    'value': w3.to_wei(0.1, 'ether'),
    'gas': 21000,
    'gasPrice': w3.eth.gas_price,
    'nonce': w3.eth.get_transaction_count(account.address),
    'chainId': w3.eth.chain_id
}

signed = account.sign_transaction(tx)
print(f'Signed Moonbase tx: {signed.raw_transaction.hex()}')

# Send later
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
print(f'Tx hash: {tx_hash.hex()}')

package main

import (
    "context"
    "crypto/ecdsa"
    "fmt"
    "log"
    "math/big"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/crypto"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://moonbase-rpc.n.dwellir.com")
    if err != nil {
        log.Fatal(err)
    }

    // Recommended: client-side signing
    privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY_HEX")
    if err != nil {
        log.Fatal(err)
    }

    publicKey := privateKey.Public().(*ecdsa.PublicKey)
    fromAddress := crypto.PubkeyToAddress(*publicKey)

    nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
    if err != nil {
        log.Fatal(err)
    }

    toAddress := common.HexToAddress("0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b")
    tx := types.NewTransaction(nonce, toAddress, big.NewInt(100000000), 21000, big.NewInt(10000000000), nil)

    chainID, err := client.ChainID(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("Signed Moonbase tx hash: %s\n", signedTx.Hash().Hex())
}

Common Use Cases

1. Offline Transaction Signing

Sign transactions on an air-gapped machine for later broadcast:

JavaScript

import { Wallet } from 'ethers';

async function createSignedTransaction(privateKey, to, value, { chainId, nonce, gasLimit }) {
  const wallet = new Wallet(privateKey);
  const tx = {
    to,
    value,
    gasLimit,
    nonce,
    chainId,
  };

  const signedTx = await wallet.signTransaction(tx);
  // Store signedTx and broadcast from an online machine
  return signedTx;
}

2. Batch Transaction Preparation

Pre-sign multiple transactions for sequential submission on Moonbase:

JavaScript

async function prepareBatch(wallet, transactions) {
  const signed = [];

  for (let i = 0; i < transactions.length; i++) {
    const tx = {
      ...transactions[i],
      nonce: baseNonce + i
    };
    signed.push(await wallet.signTransaction(tx));
  }

  return signed; // Submit via eth_sendRawTransaction in order
}

Error Handling

Common errors and solutions:

Error Code	Description	Solution
-32000	Deprecated, unavailable, or account not unlocked	Use client-side signing instead of node-side signing
-32601	Method not found	Method disabled on this node — use client-side signing
-32602	Invalid params	Verify transaction fields (from, to, gas, etc.)
-32603	Internal error	Check node logs for signing failures

eth_sendRawTransaction — Broadcast a signed transaction
eth_sendTransaction — Sign and send in one step (requires unlocked account)
eth_accounts — List accounts available for signing

eth_signTransaction - Moonbase RPC Method

When to Use This Method

Request Parameters

Response Body

Code Examples

Common Use Cases

1. Offline Transaction Signing

2. Batch Transaction Preparation

Error Handling

On this page

eth_signTransaction - Moonbase RPC Method

When to Use This Method

Request Parameters

Response Body

Code Examples

Common Use Cases

1. Offline Transaction Signing

2. Batch Transaction Preparation

Error Handling

Related Methods

On this page