Docs
Supported ChainsZetachainJSON-RPC APITransaction Methods

eth_sendTransaction - Zetachain RPC Method

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

Why Zetachain? Build on the universal omnichain blockchain enabling cross-chain smart contracts across 50+ chains including Bitcoin with native Bitcoin support, 50+ chain interoperability via UNISON, no bridging required, and partnerships with Curve and SushiSwap.

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 cross-chain dApp developers, Bitcoin DeFi builders, and teams requiring native multi-chain interoperability 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('Zetachain tx hash:', txHash);

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

const provider = new JsonRpcProvider('https://api-zetachain-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('Zetachain 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'Zetachain tx hash: {tx_hash}')

# Recommended for production: client-side signing
w3 = Web3(Web3.HTTPProvider('https://api-zetachain-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'Zetachain 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-zetachain-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("Zetachain 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 Zetachain 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 Zetachain. 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 Zetachain. Essential for reading contract state for omnichain DeFi, native Bitcoin smart contracts, cross-chain asset management, and unified liquidity aggregation.

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