Send transactions

This guide will teach you how to send a single EVM transaction. Smart Wallets make it easy!

The client defaults to using EIP-7702, so your EOA will be delegated to a smart account to enable gas sponsorship, batching, and more. The SDK handles delegation automatically on the first transaction.

API key from your dashboard
A funded Smart Wallet to cover gas fees (or a gas manager policy to sponsor gas)

@alchemy/wallet-apis (v5.x.x) is currently in beta but is the recommended replacement for @account-kit/wallet-client (v4.x.x). If you run into any issues, please reach out.

You can send transactions using the smart wallet client sendCalls action.

sendCalls.ts

import { client } from "./client.ts";
 
// Send the transaction
const { id } = await client.sendCalls({
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      value: BigInt(0),
      data: "0x",
    },
  ],
});
 
console.log({ id }); // the Call ID
 
// Wait for the transaction to be confirmed
const result = await client.waitForCallsStatus({ id });
 
console.log(result);

Using @account-kit/wallet-client (v4.x.x)?

The examples on this page use @alchemy/wallet-apis (v5.x.x). If you're using @account-kit/wallet-client (v4.x.x), the client setup looks like this:

client.ts (v4.x.x)

import { LocalAccountSigner } from "@aa-sdk/core";
import { createSmartWalletClient } from "@account-kit/wallet-client";
import { alchemy, sepolia } from "@account-kit/infra";
 
const signer = LocalAccountSigner.privateKeyToAccountSigner("0xYOUR_PRIVATE_KEY" as const);
 
export const client = createSmartWalletClient({
  transport: alchemy({ apiKey: "YOUR_API_KEY" }),
  chain: sepolia,
  signer,
  account: signer.address, // can also be passed per action as `from` or `account`
  // Optional: sponsor gas for your users (see "Sponsor gas" guide)
  policyId: "YOUR_POLICY_ID", 
});

Key v4.x.x differences:

Account address must be specified on the client or per action (from or account). In v5.x.x, the client automatically uses the signer's address as the account address via EIP-7702.
Chain imports come directly from @account-kit/infra instead of viem/chains.
Numeric values use hex strings: value: "0x0" instead of value: BigInt(0).
In v4.x.x, the paymaster capability on prepareCalls or sendCalls is called paymasterService instead of paymaster, or you can set the policyId directly on the client.
Signers use LocalAccountSigner / WalletClientSigner from @aa-sdk/core. In v5.x.x, a viem LocalAccount or WalletClient is used directly.

See the full migration guide for a complete cheat sheet.

The examples provided use jq to parse json and foundry to sign a raw payload.

See the wallet_prepareCalls, wallet_sendPreparedCalls, and wallet_getCallsStatus API reference for full descriptions of the parameters used in the following example.

ALCHEMY_API_KEY=your-alchemy-api-key
CHAIN_ID=0x66eee # Your desired chain ID as hex
SIGNER_ADDRESS=your-signer-address
SIGNER_PRIVATE_KEY=your-signer-private-key

Prepare the calls using your signer address as the from field to enable EIP-7702 by default. You can use your signer address directly without first calling wallet_requestAccount.

PREPARE_CALLS_RESPONSE=$(curl --request POST \
  --url https://api.g.alchemy.com/v2/$ALCHEMY_API_KEY \
  --header 'accept: application/json' \
  --data '
{
    "id": 1,
    "jsonrpc": "2.0",
    "method": "wallet_prepareCalls",
    "params": [
      {
        "calls": [
            {
                "to": "0x0000000000000000000000000000000000000000",
                "data": "0x",
                "value": "0x00"
            }
        ],
        "from": "'$SIGNER_ADDRESS'",
        "chainId": "'$CHAIN_ID'"
      }
    ]
}')

Sign the returned signature request. How you do this will vary depending on your environment.

If the account hasn't been delegated yet, the response type will be array containing both an EIP-7702 authorization and a user operation that need to be signed. Once delegated (after the first successful transaction), subsequent calls will only return a user operation to sign.

# Extract values from prepare calls response
CALL_TYPE=$(echo $PREPARE_CALLS_RESPONSE | jq -r .result.type)
CALL_DATA=$(echo $PREPARE_CALLS_RESPONSE | jq -r .result.data)
 
if [ "$CALL_TYPE" = "array" ]; then
  # First transaction: sign both authorization and user operation
  # Sign the 7702 authorization
  AUTH_PAYLOAD=$(echo $PREPARE_CALLS_RESPONSE | jq -r '.result.data[0].signatureRequest.rawPayload')
  AUTH_SIGNATURE=$(cast wallet sign --no-hash --private-key "$SIGNER_PRIVATE_KEY" "$AUTH_PAYLOAD")
 
  # Sign the user operation
  UO_PAYLOAD=$(echo $PREPARE_CALLS_RESPONSE | jq -r '.result.data[1].signatureRequest.data.raw')
  UO_SIGNATURE=$(cast wallet sign --private-key "$SIGNER_PRIVATE_KEY" "$UO_PAYLOAD")
 
  # Build the signed array data
  SIGNED_DATA=$(echo $PREPARE_CALLS_RESPONSE | jq -c --arg auth_sig "$AUTH_SIGNATURE" --arg uo_sig "$UO_SIGNATURE" '
    .result.data | [
      { type: .[0].type, data: .[0].data, chainId: .[0].chainId, signature: { type: "secp256k1", data: $auth_sig } },
      { type: .[1].type, data: .[1].data, chainId: .[1].chainId, signature: { type: "secp256k1", data: $uo_sig } }
    ]')
else
  # Subsequent transactions: sign only the user operation
  SIGNATURE_PAYLOAD=$(echo $PREPARE_CALLS_RESPONSE | jq -r .result.signatureRequest.data.raw)
  SIGNATURE=$(cast wallet sign --private-key "$SIGNER_PRIVATE_KEY" "$SIGNATURE_PAYLOAD")
fi

Using cast wallet sign --no-hash for the authorization payload is acceptable for testing but not recommended for production. See Using EIP-7702 for production signing recommendations.

Send the signed calls using wallet_sendPreparedCalls.

if [ "$CALL_TYPE" = "array" ]; then
  # Send the array of signed calls
  SEND_CALLS_RESPONSE=$(echo '{}' | jq -n \
    --argjson signed_data "$SIGNED_DATA" \
    --arg chain_id "$CHAIN_ID" \
    '{
      "id": 1,
      "jsonrpc": "2.0",
      "method": "wallet_sendPreparedCalls",
      "params": [{
        "type": "array",
        "data": $signed_data
      }]
    }' | curl --request POST \
      --url https://api.g.alchemy.com/v2/$ALCHEMY_API_KEY \
      --header 'accept: application/json' \
      --data @-)
else
  # Send the single user operation
  SEND_CALLS_RESPONSE=$(echo '{}' | jq -n \
    --arg call_type "$CALL_TYPE" \
    --argjson call_data "$CALL_DATA" \
    --arg chain_id "$CHAIN_ID" \
    --arg signature "$SIGNATURE" \
    '{
      "id": 1,
      "jsonrpc": "2.0",
      "method": "wallet_sendPreparedCalls",
      "params": [{
        "type": $call_type,
        "data": $call_data,
        "chainId": $chain_id,
        "signature": {
          "type": "secp256k1",
          "data": $signature
        }
      }]
    }' | curl --request POST \
      --url https://api.g.alchemy.com/v2/$ALCHEMY_API_KEY \
      --header 'accept: application/json' \
      --data @-)
fi
 
CALL_ID=$(echo $SEND_CALLS_RESPONSE | jq -r '.result.id')

Finally, use wallet_getCallsStatus to check the status of the call. A "pending" state (1xx status codes) is expected for some time before the transition to "confirmed," so this endpoint should be polled while the status is pending. If the call does not progress, refer to the retry guide. The API documentation provides details on each status code.

curl --request POST \
  --url https://api.g.alchemy.com/v2/$ALCHEMY_API_KEY \
  --header 'accept: application/json' \
  --data '
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "wallet_getCallsStatus",
  "params": [
    "'$CALL_ID'"
  ]
}'

Encoding function data

If you need to encode function data (instead of just sending value), it is easy to do so using Viem or Foundry.

In JavaScript, you can use Viem to encode function call data.

sendCalls.ts

import { encodeFunctionData } from "viem";
import { client } from "./client.ts";
import { exampleAbi } from "./abi.ts";
 
await client.sendCalls({
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      data: encodeFunctionData({
        abi: exampleAbi,
        functionName: "mintTo",
        args: ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
      }),
    },
  ],
});

You can use foundry to encode function call data. Use your signer address directly as the from field to enable EIP-7702 by default.

curl --request POST \
  --url https://api.g.alchemy.com/v2/$ALCHEMY_API_KEY \
  --header 'accept: application/json' \
  --data '
{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "wallet_prepareCalls",
  "params": [
    {
      "calls": [
        {
          "to": "0x0000000000000000000000000000000000000000",
          "data": "'$(cast calldata "mintTo(address)" $SIGNER_ADDRESS)'"
        }
      ],
      "from": "'$SIGNER_ADDRESS'",
      "chainId": "'$CHAIN_ID'"
    }
  ]
}'

Usage with prepare calls

Instead of using the sendCalls abstraction, you can prepare and send calls using underlying methods. Usage of the capability will be the same as when using send calls. It is recommended to use prepareCalls if you want to inspect the prepared call prior to prompting the user for signature.

@alchemy/wallet-apis (v5.x.x) is currently in beta but is the recommended replacement for @account-kit/wallet-client (v4.x.x). If you run into any issues, please reach out.

You can use smart wallet client actions to prepare, sign, and send transactions.

sendCalls.ts

import { client } from "./client.ts";
 
// Prepare the calls
const preparedCalls = await client.prepareCalls({
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      value: BigInt(0),
      data: "0x",
    },
  ],
});
 
// Inspect the prepared calls before signing
console.log({ preparedCalls });
 
// Sign the prepared calls
const signedCalls = await client.signPreparedCalls(preparedCalls);
 
// Send the signed calls
const sentCalls = await client.sendPreparedCalls(signedCalls);
 
console.log({ sentCalls });

See the prepareCalls, signPreparedCalls, and sendPreparedCalls SDK references for full parameter descriptions.

See the wallet_prepareCalls API reference.

Build more:

Troubleshooting:

Common errors

Send transactions

Declare your secrets

Prepare Calls

Sign the Prepared Calls

Send the Prepared Calls

Check the Calls Status

Send transactions

Prerequisites

Implementation

Declare your secrets

Prepare Calls

Sign the Prepared Calls

Send the Prepared Calls

Check the Calls Status

Advanced

Next steps