Send a transaction

sendTransaction: (input: UnsignedTransactionRequest, options?: SendTransactionOptions) => Promise<{ hash: HexString }>

import {useSendTransaction} from '@privy-io/react-auth';
const {sendTransaction} = useSendTransaction();
sendTransaction({
  to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
  value: 100000
});

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',
        },
    ],
});

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

let provider = wallet.provider

let tx = try JSONEncoder().encode([
    "to": "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
    "value": "0x186a0", // 100000 in hex
    "chainId": "0x2105", // 8453 (Base) in hex
    "from": wallet.address
])

guard let txString = String(data: tx, encoding: .utf8) else {
    print("Data encoding error")
    return
}

let transactionHash = try await provider.request(
    EthereumRpcRequest(
        method: "eth_sendTransaction",
        params: [txString]
    )
)

// Retrieve list of user's embedded Ethereum wallets
let ethereumWallets = user.embeddedEthereumWallets

// the target wallet here is looked up by it's position in the list,
// but you may choose to have some application state that includes
// it's address, and look it up that way
let wallet = wallets[1]

// Get RPC provider for wallet
let provider = wallet.provider

let response = try await provider.request(
    RpcRequest(
        method: "personal_sign",
        params: ["The message that is being signed", wallet.address]
    )
)

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(
        method = "eth_sendTransaction",
        params = listOf(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');
    },
);

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,
    },
});

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",
        }
    }
}'

{
    "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}