Send a transaction

request: (request: { method: 'eth_sendTransaction', params: [SendTransactionParams] }) => Promise<HexString>

import {useEmbeddedEthereumWallet} from '@privy-io/expo';

const {wallets} = useEmbeddedEthereumWallet();
const wallet = wallets[0];

const provider = await wallet.getProvider();
const accounts = await provider.request({
    method: 'eth_requestAccounts',
});

// Send transaction (will be signed and populated)
const response = await provider.request({
    method: 'eth_sendTransaction',
    params: [
        {
            from: accounts[0],
            to: '0x0000000000000000000000000000000000000000',
            value: '0x2386F26FC10000',
        },
    ],
});

func request(_ request: EthereumRpcRequest) async throws -> String

let provider = wallet.provider

let transaction = EthereumRpcRequest.UnsignedEthTransaction(
    from: wallet.address,
    to: "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
    value: .int(10000),
    chainId: .hexadecimal("0x2105") // Base, in hex
)

let transactionHash = try await provider.request(.ethSendTransaction(transaction: transaction)

public suspend fun request(request: EthereumRpcRequest): Result<EthereumRpcResponse>

val transaction = JSONObject().apply {
    put("to", "0xE3070d3e4309afA3bC9a6b057685743CF42da77C")
    put("value", "0x186a0") // 100000 in hex
    put("chainId", "0x2105") // 8453 (Base) in hex
    put("from", ethereumWallet.address)
}.toString()

val result = ethereumWallet.provider.request(
    request = EthereumRpcRequest.ethSendTransaction(transaction),
)

when (result) {
    is Result.Success -> {
        val transactionHash = result.data.data
        // Handle successful transaction
    }
    is Result.Failure -> {
        // Handle error
    }
}

public Task<RpcResponse> Request(RpcRequest request);

// Create transaction JSON
string transactionJson = JsonUtility.ToJson(new {
    to = "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
    value = "0x186a0", // 100000 in hex
    chainId = "0x2105", // 8453 (Base) in hex
    from = embeddedWallet.Address
});

// Create RPC request
var rpcRequest = new RpcRequest
{
    Method = "eth_sendTransaction",
    Params = new string[] { transactionJson }
};

// Send transaction
RpcResponse transactionResponse = await embeddedWallet.RpcProvider.Request(rpcRequest);

// Transaction hash is in the response data
string transactionHash = transactionResponse.Data;

Future<Result<EthereumRpcResponse>> request(EthereumRpcRequest request);

// Create transaction parameters as a Map
final transactionMap = {
    'to': '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
    'value': '0x186a0', // 100000 in hex
    'chainId': '0x2105', // 8453 (Base) in hex
    'from': ethereumWallet.address
};

// Convert Map to JSON string
final transactionJson = jsonEncode(transactionMap);

// Create the RPC request
final rpcRequest = EthereumRpcRequest(
    method: 'eth_sendTransaction',
    params: [transactionJson],
);

// Send the transaction
final result = await ethereumWallet.provider.request(rpcRequest);

// Handle the result
result.when(
    success: (response) {
        final transactionHash = response.data;
        print('Transaction sent with hash: $transactionHash');
    },
    failure: (error) {
        print('Failed to send transaction: $error');
    },
);

const {hash, caip2} = await privy.wallets().ethereum().sendTransaction('insert-wallet-id', {
    caip2: 'eip155:8453',
    params: {
        transaction: {
            to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
            value: '0x2386F26FC10000',
            chain_id: 8453,
        },
    },
    sponsor: true,
});

sendTransaction: (input: EthereumSendTransactionInputType) => Promise<EthereumSendTransactionResponseType>

const {hash, caip2} = await privy.walletApi.ethereum.sendTransaction({
    walletId: 'insert-wallet-id',
    caip2: 'eip155:8453',
    transaction: {
        to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
        value: '0x2386F26FC10000',
        chainId: 8453,
    },
    sponsor: true,
});

https://api.privy.io/v1/wallets/<wallet_id>/rpc

$ curl --request POST https://api.privy.io/v1/wallets/<wallet_id>/rpc \
-u "<your-privy-app-id>:<your-privy-app-secret>" \
-H "privy-app-id: <your-privy-app-id>" \
-H "privy-authorization-signature: <authorization-signature-for-request>" \
-H 'Content-Type: application/json' \
-d '{
    "method": "eth_sendTransaction",
    "caip2": "eip155:1",
    "params": {
        "transaction": {
            "to": "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
            "value": "0x2386F26FC10000",
        }
    },
    "sponsor": true
}'

{
    "method": "eth_sendTransaction",
    "data": {
        "hash": "<transaction-hash>",
        "caip2": "eip155:1"
    }
}

from .internal_client import generate_client
client = generate_client()

tx = client.wallets.rpc(
    wallet_id=user.wallet_id,
    method="eth_sendTransaction",
    caip2="eip155:1",
    params={
        "transaction": {
            "to": "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
            "value": 100000,
        },
    },
)
return {"data": tx.data}

try {
    String caip2 = "eip155:11155111"; // Sepolia testnet

    EthereumSendTransactionRpcInputTransaction txn = EthereumSendTransactionRpcInputTransaction.builder()
        .to(recipientAddress)
        .value(EthereumSendTransactionRpcInputValue.of("0x1")) // 1 wei
        .chainId(EthereumSendTransactionRpcInputChainId.of(11_155_111)) // Sepolia testnet
        .build();

    // Example: If wallet's owner is an authorization private key
    AuthorizationContext authorizationContext = AuthorizationContext.builder()
        .addAuthorizationPrivateKey("authorization-key")
        .build();

    EthereumSendTransactionRpcResponseData response = privyClient
        .wallets()
        .ethereum()
        .sendTransaction(
            walletId,
            caip2,
            txn,
            authorizationContext
        );

    String transactionHash = response.hash();
} catch (APIException e) {
    String errorBody = e.bodyAsString();
    System.err.println(errorBody);
} catch (Exception e) {
    System.err.println(e.getMessage());
}

use privy_rs::{AuthorizationContext, PrivyClient};

let client = PrivyClient::new("app_id".to_string(), "app_secret".to_string())?;
let ethereum_service = client.wallets().ethereum();
let auth_ctx = AuthorizationContext::new();

let transaction = EthereumSendTransactionRpcInputParamsTransaction {
    to: Some("0x742d35Cc6635C0532925a3b8c17d6d1E9C2F7ca".to_string()),
    value: None,
    gas_limit: None,
    max_fee_per_gas: None,
    max_priority_fee_per_gas: None,
    data: None,
    chain_id: None,
    from: None,
    gas_price: None,
    nonce: None,
    type_: None,
};

let result = ethereum_service
    .send_transaction(
        &wallet_id,
        "eip155:1",
        transaction,
        &auth_ctx,
        None,
    )
    .await?;

println!("Transaction sent successfully");