eth_sendRawTransaction — Elysium JSON-RPC
Submit a locally signed transaction to Elysium mainnet.
https://triport.io/rpc/elysium- Network
- Elysium mainnet (chain ID 99901)
- Scope
- elysium:rpc
- Auth
- X-API-Key: $TRIPORT_API_KEY
- Rate limit
- elysium_send_tx - 3 / 5 / 30 / 80 / 80 RPS (Free / Basic / Pro / Business / Enterprise); Limits
Endpoint and plans: Elysium RPC endpoint.
Sign locally with chainId 99901 (0x1863d); gas is paid in HYPE. Submit the encoded bytes, never a private key. Supported envelopes are replay-protected legacy (EIP-155), type 1 (EIP-2930), type 2 (EIP-1559), and type 4 (EIP-7702). Legacy without EIP-155, type 3 (blob), and system transaction types are rejected. Raw transactions are limited to 128 KB.
Example type 2 transfer parameters from the 2026-11-08 research snapshot:
| Field | Example |
|---|---|
| chainId | 99901 |
| maxFeePerGas | 0.25 gwei = 250000000 wei |
| maxPriorityFeePerGas | 0.01 gwei = 10000000 wei |
| gas | 21000 for an ordinary native-token transfer |
These are example fee caps, not a fixed network fee. Check current fees and use eth_estimateGas for contract calls and other transactions; do not assume 21000 covers them. Fetch the nonce with eth_getTransactionCount using pending, and coordinate nonces when sending concurrently.
Parameters
rawTransactionhex datarequiredResponse
Success returns the 32-byte transaction hash, keccak256(rawTransaction). Illustrative response; the hash below is synthetic, not a captured submission:
A hash means submission was accepted; it does not prove inclusion or successful execution. Re-submitting identical bytes is idempotent: if that transaction is already found in the chain, its hash is returned.
Unknown outcome
If both nodes time out (or all attempts fail with transport/server errors), the transaction may already have reached the sequencer. After a lookup fails to resolve it, the response is -32000, with the locally computed hash returned in error.data.txHash and outcome: "unknown". It is not a successful result and does not mean the transaction was rejected. Triport does not automatically resend it.
Illustrative error envelope (the explanatory message is shortened):
{"jsonrpc":"2.0","id":1,"error":{"code":-32000,"message":"transaction submission outcome unknown; check the transaction hash before sending again","data":{"txHash":"0x1111111111111111111111111111111111111111111111111111111111111111","outcome":"unknown"}}}Keep the signed bytes and hash before submitting. Poll eth_getTransactionByHash and eth_getTransactionReceipt. A null receipt means no receipt is currently known; it is not proof of rejection. If you choose to retry after checking, resend the same raw transaction. Signing a different transaction can create a separate transfer.
Errors
Network errors such as nonce too low, replacement underpriced, and insufficient funds are passed through with their network code and message, subject to removal of infrastructure identifiers. Inspect the complete error. A nonce error is resolved to a hash only when lookup finds that same transaction already in the chain.
| Code | Meaning | Action |
|---|---|---|
| -32602 | Invalid bytes, envelope, chain ID or size. Measured through Triport (2026-11-08): 0xdeadbeef returns "raw transaction is not a valid signed transaction"; an empty params array returns "missing raw transaction parameter". | Correct the signed transaction. |
| -32601 | Submission unavailable on the serving node | Do not resend blindly; check the hash. |
| -32005 | Node pool at capacity (HTTP 429); nothing was sent when explicitly stated | Honor Retry-After and use bounded backoff. |
| HTTP 429 rate_limited | Plan send RPS exceeded (plain HTTP error); nothing was sent | Honor Retry-After. |
| HTTP 403 method_unknown | eth_sendTransaction (node-side signing) or another method outside the Elysium set | Sign locally and submit the raw bytes. |
| -32000 | Network rejection or unknown outcome | Inspect message and data; poll the hash for outcome unknown. |
Receipt and finality
Poll eth_getTransactionReceipt until non-null, then inspect status (0x1 success, 0x0 revert). A receipt usually appears within seconds of sequencer inclusion; this is an expectation, not a measured production timing guarantee. Do not wait for the DAS batch feed to discover your receipt.
The block becomes finalized after its batch is published on HyperEVM, on a scale of minutes. Poll eth_getBlockByNumber with finalized and compare its height with the receipt block. Receipt availability and settlement finality are separate stages. The bridge withdrawal challenge window is also separate; see Bridge.
Examples
These examples sign a type 2 transfer and submit it when run. Set TRIPORT_API_KEY, PRIVATE_KEY, and TO_ADDRESS locally. The value is 1 wei. Persist the raw bytes and locally computed hash before submission. If an SDK throws on unknown outcome, use that hash for receipt polling; the examples do not automatically resubmit.
viem
import { createPublicClient, createWalletClient, defineChain, http, keccak256 } from "viem";
import { privateKeyToAccount } from "viem/accounts";
const url = "https://triport.io/r/" + encodeURIComponent(process.env.TRIPORT_API_KEY) + "/elysium";
const chain = defineChain({ id: 99901, name: "Elysium", nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 }, rpcUrls: { default: { http: [url] } } });
const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const client = createPublicClient({ chain, transport: http(url, { retryCount: 0 }) });
if (await client.getChainId() !== 99901) throw new Error("Unexpected chain");
const wallet = createWalletClient({ account, chain, transport: http(url, { retryCount: 0 }) });
const raw = await wallet.signTransaction({
to: process.env.TO_ADDRESS, value: 1n, type: "eip1559",
nonce: await client.getTransactionCount({ address: account.address, blockTag: "pending" }),
gas: 21000n, maxFeePerGas: 250000000n, maxPriorityFeePerGas: 10000000n,
});
const hash = keccak256(raw);
console.log("Track this hash even if submission throws:", hash);
await client.sendRawTransaction({ serializedTransaction: raw });
console.log(await client.waitForTransactionReceipt({ hash }));ethers v6
import { FetchRequest, JsonRpcProvider, Wallet, keccak256 } from "ethers";
const url = "https://triport.io/r/" + encodeURIComponent(process.env.TRIPORT_API_KEY) + "/elysium";
const request = new FetchRequest(url);
request.setThrottleParams({ maxAttempts: 1 });
const provider = new JsonRpcProvider(request);
if (BigInt(await provider.send("eth_chainId", [])) !== 99901n) throw new Error("Unexpected chain");
const account = new Wallet(process.env.PRIVATE_KEY);
const raw = await account.signTransaction({
chainId: 99901, type: 2, to: process.env.TO_ADDRESS, value: 1n,
nonce: await provider.getTransactionCount(account.address, "pending"),
gasLimit: 21000n, maxFeePerGas: 250000000n, maxPriorityFeePerGas: 10000000n,
});
const hash = keccak256(raw);
console.log("Track this hash even if submission throws:", hash);
await provider.broadcastTransaction(raw);
console.log(await provider.waitForTransaction(hash));web3.py
import os
from urllib.parse import quote
from web3 import Web3
url = "https://triport.io/r/" + quote(os.environ["TRIPORT_API_KEY"], safe="") + "/elysium"
w3 = Web3(Web3.HTTPProvider(url, exception_retry_configuration=None))
if w3.eth.chain_id != 99901:
raise RuntimeError("Unexpected chain")
account = w3.eth.account.from_key(os.environ["PRIVATE_KEY"])
signed = account.sign_transaction({
"chainId": 99901, "type": 2,
"to": Web3.to_checksum_address(os.environ["TO_ADDRESS"]), "value": 1,
"nonce": w3.eth.get_transaction_count(account.address, "pending"),
"gas": 21000, "maxFeePerGas": 250000000, "maxPriorityFeePerGas": 10000000,
})
tx_hash = Web3.keccak(signed.raw_transaction)
print("Track this hash even if submission throws:", Web3.to_hex(tx_hash))
w3.eth.send_raw_transaction(signed.raw_transaction)
print(w3.eth.wait_for_transaction_receipt(tx_hash))SDK transport references: ethers FetchRequest and web3.py HTTPProvider. The examples disable transport retries for submission.
Related
Overview · Limits · Errors · Bridge · Batch history