Docs
Moonbase alpha

eth_sendTransaction - Moonbase RPC Method

Send a transaction from an unlocked account on Moonbase Alpha. Requires the node to hold the sender's private key — intended for development and testing only.

Creates and sends a new transaction from an unlocked account on Moonbase Alpha. The node signs the transaction server-side using the private key associated with the from address.

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 manage unlocked accounts for you. On shared infrastructure, eth_sendTransaction commonly returns an unsupported-method response or an account-management error such as unknown account, depending on the client. For production applications, sign transactions client-side and use eth_sendRawTransaction instead.

When to Use This Method

eth_sendTransaction is useful for Moonbeam developers, dApp testers, and teams validating cross-chain integrations in development scenarios:

  • Local Development — Send transactions quickly on local nodes (Hardhat, Anvil, Ganache) without managing private keys
  • Testing Workflows — Rapidly prototype and test contract interactions on dev networks
  • Scripted Deployments — Deploy contracts on private or permissioned networks with unlocked accounts

Request Parameters

Request
fromDATA (20 bytes)

Address of the sending account (must be unlocked on the node)

toDATA (20 bytes)

Recipient address (omit for contract creation)

gasQUANTITY

Gas limit (default: 90000)

gasPriceQUANTITY

Gas price in wei (legacy transactions)

maxFeePerGasQUANTITY

Maximum total fee per gas (EIP-1559 transactions)

maxPriorityFeePerGasQUANTITY

Maximum priority fee per gas (EIP-1559 transactions)

valueQUANTITY

Value to send in wei

dataDATA

Compiled contract code or encoded method call

Response Body

Response
resultDATA (32 bytes)

The transaction hash, or zero hash if the transaction is not yet available

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_sendTransaction",
    "params": [{
      "from": "0x407d73d8a49eeb85d32cf465507dd71d507100c1",
      "to": "0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b",
      "gas": "0x76c0",
      "gasPrice": "0x9184e72a000",
      "value": "0x9184e72a"
    }],
    "id": 1
  }'
JavaScript
// On a local dev node with unlocked accounts (e.g., Hardhat)
const response = await fetch('http://127.0.0.1:8545', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    jsonrpc: '2.0',
    method: 'eth_sendTransaction',
    params: [{
      from: '0x407d73d8a49eeb85d32cf465507dd71d507100c1',
      to: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
      gas: '0x76c0',
      gasPrice: '0x9184e72a000',
      value: '0x9184e72a'
    }],
    id: 1
  })
});

const { result: txHash } = await response.json();
console.log('Moonbase tx hash:', txHash);

// Recommended for production: client-side signing
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 = await wallet.sendTransaction({
  to: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
  value: parseEther('0.1')
});
console.log('Moonbase tx hash:', tx.hash);
Python
import requests
from web3 import Web3

# Direct RPC call on a LOCAL dev node with unlocked accounts
response = requests.post(
    'http://127.0.0.1:8545',
    json={
        'jsonrpc': '2.0',
        'method': 'eth_sendTransaction',
        'params': [{
            'from': '0x407d73d8a49eeb85d32cf465507dd71d507100c1',
            'to': '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
            'gas': '0x76c0',
            'gasPrice': '0x9184e72a000',
            'value': '0x9184e72a'
        }],
        'id': 1
    }
)
tx_hash = response.json()['result']
print(f'Moonbase tx hash: {tx_hash}')

# Recommended for production: client-side signing
w3 = Web3(Web3.HTTPProvider('https://moonbase-rpc.n.dwellir.com'))
account = w3.eth.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)
tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
print(f'Moonbase tx hash: {tx_hash.hex()}')
Go
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 with eth_sendRawTransaction
    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")
    gasPrice, err := client.SuggestGasPrice(context.Background())
    if err != nil {
        log.Fatal(err)
    }

    tx := types.NewTransaction(nonce, toAddress, big.NewInt(100000000), 21000, gasPrice, 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)
    }

    err = client.SendTransaction(context.Background(), signedTx)
    if err != nil {
        log.Fatal(err)
    }

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

Common Use Cases

1. Local Development with Hardhat

Send transactions using Hardhat's pre-funded unlocked accounts:

JavaScript
async function devTransfer(provider, from, to, value) {
  const txHash = await provider.send('eth_sendTransaction', [{
    from,
    to,
    value: '0x' + value.toString(16),
    gas: '0x5208' // 21000
  }]);

  const receipt = await provider.waitForTransaction(txHash);
  console.log(`Transfer confirmed in block ${receipt.blockNumber}`);
  return receipt;
}

2. Contract Deployment on Dev Network

Deploy contracts without managing private keys locally:

JavaScript
async function deployContract(provider, from, bytecode) {
  const txHash = await provider.send('eth_sendTransaction', [{
    from,
    data: bytecode,
    gas: '0x4C4B40' // 5,000,000
  }]);

  const receipt = await provider.waitForTransaction(txHash);
  console.log(`Contract deployed at: ${receipt.contractAddress}`);
  return receipt.contractAddress;
}

3. Batch Transfers in Testing

Send multiple test transactions on Moonbase dev networks:

JavaScript
async function batchTransfer(provider, from, recipients) {
  const hashes = [];

  for (const { to, value } of recipients) {
    const hash = await provider.send('eth_sendTransaction', [{
      from,
      to,
      value: '0x' + value.toString(16),
      gas: '0x5208'
    }]);
    hashes.push(hash);
  }

  return hashes;
}

Error Handling

Common errors and solutions:

Error CodeDescriptionSolution
-32000Method unavailable or unknown accountUse client-side signing with eth_sendRawTransaction
-32000Insufficient fundsEnsure from address has enough balance for value + gas
-32000Nonce too lowA transaction with this nonce was already mined — let the node auto-assign
-32601Method not foundMethod disabled on this node — use client-side signing
-32602Invalid paramsVerify transaction object fields and hex encoding

On this page

When to Use This Method
Code Examples
Common Use Cases
1. Local Development with Hardhat
2. Contract Deployment on Dev Network
3. Batch Transfers in Testing
Error Handling
Related Methods