Sign a transaction

request: (request: { method: 'eth_signTransaction', params: [SignTransactionParams] }) => 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',
});

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

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

let provider = wallet.provider

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

let transactionSignature = try await provider.request(.ethSignTransaction(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.ethSignTransaction(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_signTransaction",
    Params = new string[] { transactionJson }
};

// Sign 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_signTransaction',
    params: [transactionJson],
);

// Sign 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 sign transaction: $error');
    },
);

const {signed_transaction, encoding} = await privy.wallets().ethereum().signTransaction('insert-wallet-id', {
    params: {
        transaction: {
            to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
            value: '0x2386F26FC10000',
            chain_id: 8453,
        },
    }
});

signTransaction: (input: EthereumSignTransactionInputType) => Promise<EthereumSignTransactionResponseType>

const {signedTransaction, encoding} = await privy.walletApi.ethereum.signTransaction({
    walletId: 'insert-wallet-id',
    transaction: {
        to: '0xE3070d3e4309afA3bC9a6b057685743CF42da77C',
        value: '0x2386F26FC10000',
        chainId: 8453,
    },
});

try {
    EthereumSignTransactionRpcInputTransaction txn = EthereumSignTransactionRpcInputTransaction.builder()
        .to(recipientAddress)
        .value(EthereumSignTransactionRpcInputValue.of("0x1")) // 1 wei
        .chainId(EthereumSignTransactionRpcInputChainId.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();

    EthereumSignTransactionRpcResponseData response = privyClient
        .wallets()
        .ethereum()
        .signTransaction(
            walletId,
            txn,
            authorizationContext
    );

    String signedTransaction = response.signedTransaction();
} 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 = EthereumSignTransactionRpcInputParamsTransaction {
    to: Some("0x742d35Cc6635C0532925a3b8c17d6d1E9C2F7ca".to_string()),
    value: None,
    gas_limit: None,
    gas_price: None,
    nonce: None,
    chain_id: None,
    data: None,
    from: None,
    max_fee_per_gas: None,
    max_priority_fee_per_gas: None,
    type_: None,
};

let signed_tx = ethereum_service
    .sign_transaction(&wallet_id, transaction, &auth_ctx, None)
    .await?;

println!("Transaction signed successfully");

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_signTransaction",
    "params": {
        "transaction": {
          "to": "0xE3070d3e4309afA3bC9a6b057685743CF42da77C",
          "value": "0x2386F26FC10000",
          "chain_id": 1,
          "type": 2,
          "gas_limit": "0x5208",
          "nonce": 1,
          "max_fee_per_gas": "0x14bf7dadac",
          "max_priority_fee_per_gas": "0xf4240"
        }
    }
}'

{
  "method": "eth_signTransaction",
  "data": {
    "signed_transaction": "0x28eac519bf4051a624d4246a5788667baf84dcd7d2a439b314b339013b5cdb4c",
    "encoding": "rlp"
  }
}