Transaction SDK quickstart

This quickstart shows you how to prepare and send a transaction in minutes.

To use this guide, you'll need:

An account you can sign with (e.g. an authentication provider or an EOA)
An API key — create an app to get one
A gas manager policy ID if sponsoring gas

Don't have an API key?

Start using the Wallets API today! Get started for free.

@alchemy/wallet-apis (v5.x.x) is the recommended SDK and is currently in beta. If you're still on v4.x.x, see the migration guide.

You're going to need @alchemy/wallet-apis and viem.

npm install @alchemy/wallet-apis viem

This quickstart uses a local private key as an example. You can use any viem-compatible signer, including providers like Privy and Turnkey.

import { createSmartWalletClient, alchemyWalletTransport } from "@alchemy/wallet-apis";
import { arbitrumSepolia } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
 
const client = createSmartWalletClient({
  transport: alchemyWalletTransport({
    apiKey: "YOUR_API_KEY",
  }),
  chain: arbitrumSepolia,
  signer: privateKeyToAccount("0xYOUR_PRIVATE_KEY" as const),
  paymaster: {
    policyId: "YOUR_POLICY_ID",
  },
});

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

import { zeroAddress } from "viem";
 
const { id } = await client.sendCalls({
  calls: [{ to: zeroAddress, value: BigInt(0) }],
});

const status = await client.waitForCallsStatus({ id });
const txHash = status.receipts?.[0]?.transactionHash;
console.log(`Explorer: https://sepolia.arbiscan.io/tx/${txHash}`);

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 owner'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.
Owners 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.

This guide demonstrates how to use the wallet_prepareCalls, wallet_sendPreparedCalls, and wallet_getCallsStatus endpoints.

For a complete working example with bash scripts using jq and foundry for signing, see Send Transactions.

flowchart LR
    A[prepareCalls] --> B[sendPreparedCalls]
    B --> C[getCallsStatus]

Use your authentication address directly as the from field to enable EIP-7702 by default. The signer can be any Ethereum wallet key.

curl --request POST \
    --url https://api.g.alchemy.com/v2/API_KEY \
    --header 'accept: application/json' \
    --header 'content-type: application/json' \
    --data '
{
    "id": 1,
    "jsonrpc": "2.0",
    "method": "wallet_prepareCalls",
    "params": [
        {
            "capabilities": {
                "paymasterService": {
                    "policyId": "GAS_MANAGER_POLICY_ID"
                }
            },
            "calls": [
                {
                    "to": "0x0000000000000000000000000000000000000000"
                }
            ],
            "from": "0xSIGNER_ADDRESS",
            "chainId": "0xCHAIN_ID"
        }
    ]
}
'

If the account hasn't been delegated yet, the response type will be array containing both an EIP-7702 authorization and a transaction to sign:

{
    "type": "array",
    "data": [
        {
            "type": "eip-7702-authorization",
            "data": {...authorizationData},
            "chainId": "0xCHAIN_ID",
            "signatureRequest": {
                "type": "eth_signAuthorization",
                "rawPayload": "0xAUTH_PAYLOAD_TO_SIGN"
            }
        },
        {
            "type": "user-operation-v070",
            "data": {...useropRequest},
            "chainId": "0xCHAIN_ID",
            "signatureRequest": {
                "type": "personal_sign",
                "data": {
                    "raw": "0xHASH_TO_SIGN"
                },
                "rawPayload": "0xRAW_PAYLOAD_TO_SIGN"
            }
        }
    ]
}

On subsequent transactions (after the account is delegated), the response will be a single transaction to sign:

{
    "type": "user-operation-v070",
    "data": {...useropRequest},
    "chainId": "0xCHAIN_ID",
    "signatureRequest": {
        "type": "personal_sign",
        "data": {
            "raw": "0xHASH_TO_SIGN"
        },
        "rawPayload": "0xRAW_PAYLOAD_TO_SIGN"
    }
}

Sign the returned signature request(s) using your signer key.

If the account isn't delegated yet (array response): Sign both the EIP-7702 authorization and the transaction. The authorization only needs to be signed once to delegate your account.

Once delegated: Sign only the transaction.

If using a Smart Wallets authentication provider, learn how to stamp the request on the frontend here. When using this authentication provider, sign the signatureRequest.rawPayload directly.

If you are using a library such as Viem that supports the personal_sign method, use that to sign the transaction hash (since the signatureRequest.type is "personal_sign").

With the signature(s) from step 2 and the data from step 1, you're good to send the call!

If the account isn't delegated yet (array response):

curl --request POST \
    --url https://api.g.alchemy.com/v2/API_KEY \
    --header 'accept: application/json' \
    --header 'content-type: application/json' \
    --data '
{
    "id": 1,
    "jsonrpc": "2.0",
    "method": "wallet_sendPreparedCalls",
    "params": [
        {
            "type": "array",
            "data": [
                {
                    "type": "eip-7702-authorization",
                    "data": {...authorizationData},
                    "chainId": "0xCHAIN_ID",
                    "signature": {
                        "type": "secp256k1",
                        "data": "0xAUTH_SIGNATURE"
                    }
                },
                {
                    "type": "user-operation-v070",
                    "data": {...useropRequest},
                    "chainId": "0xCHAIN_ID",
                    "signature": {
                        "type": "secp256k1",
                        "data": "0xUSEROP_SIGNATURE"
                    }
                }
            ]
        }
    ]
}
'

Once delegated:

curl --request POST \
    --url https://api.g.alchemy.com/v2/API_KEY \
    --header 'accept: application/json' \
    --header 'content-type: application/json' \
    --data '
{
    "id": 1,
    "jsonrpc": "2.0",
    "method": "wallet_sendPreparedCalls",
    "params": [
        {
            "type": "user-operation-v070",
            "data": {...useropRequest},
            "chainId": "0xCHAIN_ID",
            "signature": {
                "type": "secp256k1",
                "data": "0xUSEROP_SIGNATURE"
            }
        }
    ]
}
'

This will return the call ID!

Call wallet_getCallsStatus to check the status of the calls. A “pending” state (1xx status codes) is expected for some time before the transition to “confirmed,” so poll this endpoint while the status is pending. If the call does not progress, refer to the retry guide.

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

See here for all of the possible results.

Transaction SDK quickstart

1. Install

2. Create a client

3. Send a sponsored transaction

4. Wait for the transaction to be confirmed

Next steps

1. Prepare calls

2. Sign the signature request(s)

3. Send the prepared calls

4. Check the calls status