Docs
Supported ChainsXDC NetworkJSON-RPC APITransaction Methods

eth_sendTransaction - XDC Network RPC Method

Send a transaction from an unlocked account on XDC Network. 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 XDC Network. The node signs the transaction server-side using the private key associated with the from address.

Why XDC Network? Build on the enterprise-grade blockchain for trade finance with 2-second finality and ISO 20022 compliance with ISO 20022 messaging, ITFA membership, Contour Network acquisition, 801M+ transactions, and partnerships with Circle and Deutsche Telekom.

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 trade finance developers, enterprise blockchain teams, and RWA tokenization builders 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('XDC Network tx hash:', txHash);

// Recommended for production: client-side signing
import { Wallet, JsonRpcProvider, parseEther } from 'ethers';

const provider = new JsonRpcProvider('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY');
const wallet = new Wallet('YOUR_PRIVATE_KEY', provider);

const tx = await wallet.sendTransaction({
  to: '0xa94f5374fce5edbc8e2a8697c15331677e6ebf0b',
  value: parseEther('0.1')
});
console.log('XDC Network 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'XDC Network tx hash: {tx_hash}')

# Recommended for production: client-side signing
w3 = Web3(Web3.HTTPProvider('https://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY'))
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'XDC Network 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://api-xdc-mainnet.n.dwellir.com/YOUR_API_KEY")
    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("XDC Network 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 XDC Network 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

eth_signTransaction

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

eth_call

Execute smart contract calls without creating transactions on XDC Network. Essential for reading contract state for tokenized trade finance (Letters of Credit, Bills of Lading), cross-border payments, and real-world asset tokenization.

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