Tempo Transactions

Tempo Transactions let apps batch, sponsor, schedule, and parallelize payments through a native transaction type.

Accept payments

Send payments Transaction guide

Flexible fees for apps using stablecoins.

Pay fees in supported stablecoins, keep payment costs predictable with dedicated blockspace, and sponsor fees for users.

Explore transactions Read docs

fee-token.ts

import { parseUnits } from "viem";
import { client } from "./viem.config";
 
const alphaUsd = '0x20c0000000000000000000000000000000000001';
const betaUsd = '0x20c0000000000000000000000000000000000002';
 
const receipt = await client.token.transferSync({
  amount: parseUnits('100', 6),
  feeToken: betaUsd,
  to: '0x0000000000000000000000000000000000000000',
  token: alphaUsd,
});

use tempo_alloy::rpc::TempoTransactionRequest;
 
let pending = provider
    .send_transaction(TempoTransactionRequest {
        calls,
        fee_token: Some(beta_usd),
        ..Default::default()
    })
    .await?;

cast erc20 transfer \
  0x20c0000000000000000000000000000000000001 \
  0x0000000000000000000000000000000000000000 \
  100000000 \
  --tempo.fee-token 0x20c0000000000000000000000000000000000002 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"

payment-lanes.ts

import { parseUnits } from "viem";
import { client } from "./viem.config";
 
const alphaUsd = '0x20c0000000000000000000000000000000000001';
 
const { receipt } = await client.token.transferSync({
  amount: parseUnits('100', 6),
  to: '0x0000000000000000000000000000000000000000',
  token: alphaUsd,
});
 
// TIP-20 payments use the payment lane automatically.

let call_data = ITIP20::transferCall {
    to: recipient,
    amount: U256::from(100_000_000),
}
.abi_encode();
 
let tx = TempoTransactionRequest::default()
    .with_to(alpha_usd)
    .with_input(call_data.into());
 
provider.send_transaction(tx).await?;

sponsor-fees.ts

import { parseUnits } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { client } from "./viem.config";
 
const sender = privateKeyToAccount('0x...');
const sponsor = privateKeyToAccount('0x...');
 
const { receipt } = await client.token.transferSync({
  account: sender,
  amount: parseUnits('10.5', 6),
  feePayer: sponsor,
  to: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEbb',
  token: '0x20c0000000000000000000000000000000000000',
});

use alloy::signers::{local::PrivateKeySigner, SignerSync};
 
let request = TempoTransactionRequest {
    calls,
    ..Default::default()
};
 
let mut tx = provider.fill(request).await?.build_aa()?;
let sender = provider.default_signer_address();
let hash = tx.fee_payer_signature_hash(sender);
 
let fee_payer: PrivateKeySigner = "0x...".parse()?;
tx.fee_payer_signature = Some(fee_payer.sign_hash_sync(&hash)?);
provider.send_transaction(tx).await?;

FEE_PAYER_HASH=$(cast mktx $TOKEN \
  "transfer(address,uint256)" $USER 10500000 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$SENDER_KEY" \
  --tempo.print-sponsor-hash)
 
SPONSOR_SIG=$(cast wallet sign --private-key "$SPONSOR_KEY" "$FEE_PAYER_HASH" --no-hash)
 
cast send $TOKEN \
  "transfer(address,uint256)" $USER 10500000 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$SENDER_KEY" \
  --tempo.sponsor-signature "$SPONSOR_SIG"

access-keys.ts

import { generatePrivateKey } from "viem/accounts";
import { Account, Actions, Expiry } from "viem/tempo";
import { client } from "./viem.config";
 
// Create a scoped P256 access key.
const accessKey = Account.fromP256(generatePrivateKey(), {
  access: client.account,
});
 
// Authorize it for one week.
const authorization = await Actions.accessKey.signAuthorization(
  client,
  { accessKey, expiry: Expiry.days(7) },
);
 
await client.account.authorizeAccessKey(authorization);

use alloy::primitives::{Address, U256};
use tempo_alloy::contracts::precompiles::{
    IAccountKeychain, TokenLimit, ACCOUNT_KEYCHAIN,
};
 
let keychain = IAccountKeychain::new(ACCOUNT_KEYCHAIN, provider.clone());
let expiry = now + 7 * 24 * 60 * 60;
 
keychain
    .authorizeKey(
        access_key,
        1u8,
        expiry,
        true,
        vec![TokenLimit {
            token: alpha_usd,
            amount: U256::from(500_000_000),
        }],
    )
    .send()
    .await?;

EXPIRY=$(($(date +%s) + 604800))
 
cast send $ACCOUNT_KEYCHAIN \
  "authorizeKey(address,uint8,uint64,bool,(address,uint256)[])" \
  "$ACCESS_KEY" \
  1 \
  "$EXPIRY" \
  true \
  "[($TOKEN,500000000)]" \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$ROOT_KEY"

Set spending limits using access keys.

Authorize scoped keys with spending limits and expiry so apps and agents can move approved funds without repeated user prompts.

Access keys Read docs

Scoped signing

Delegate one flow without delegating the account.

Spend limits

Cap what a key can move before it ever signs.

Revocation

Turn off old keys without rotating the root.

Transaction controls for production throughput.

Batch calls, parallelize independent transactions, and schedule execution windows for high-volume services.

Explore transactions Read docs

batch.ts

import { client } from "./viem.config";
 
const { address, hash, id } = await client.sendTransaction({
  calls: [
    { to: tokenAddress, data: transferCalldata },
    { to: anotherTokenAddress, data: approveCalldata },
    { to: dexAddress, data: swapCalldata },
  ],
});

let tx = TempoTransactionRequest {
    calls: vec![transfer_call, approve_call, swap_call],
    ..Default::default()
};
 
let receipt = provider
    .send_transaction(tx)
    .await?
    .get_receipt()
    .await?;

cast batch-send \
  --call "$TOKEN::transfer(address,uint256):$ALICE,100000000" \
  --call "$TOKEN::transfer(address,uint256):$BOB,50000000" \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"

parallel.ts

import { parseUnits } from "viem";
import { client } from "./viem.config";
 
const alphaUsd = '0x20c0000000000000000000000000000000000001';
 
const [receipt1, receipt2] = await Promise.all([
  client.token.transferSync({
    amount: parseUnits('100', 6),
    nonceKey: 7,
    to: '0x70997970C51812dc3A010C7d01b50e0d17dc79C8',
    token: alphaUsd,
  }),
  client.token.transferSync({
    amount: parseUnits('50', 6),
    nonceKey: 8,
    to: '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC',
    token: alphaUsd,
  }),
]);

let tx_a = TempoTransactionRequest {
    calls: vec![payment_a],
    nonce_key: U256::from(7),
    ..Default::default()
};
let tx_b = TempoTransactionRequest {
    calls: vec![payment_b],
    nonce_key: U256::from(8),
    ..Default::default()
};
 
let (a, b) = tokio::try_join!(
    provider.send_transaction(tx_a),
    provider.send_transaction(tx_b),
)?;

cast erc20 transfer "$TOKEN" "$ALICE" 100000000 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY" \
  --nonce 0 --tempo.nonce-key 7 &
cast erc20 transfer "$TOKEN" "$BOB" 50000000 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY" \
  --nonce 0 --tempo.nonce-key 8 &
wait

schedule.ts

import { client } from "./viem.config";
 
const now = Math.floor(Date.now() / 1000);
 
const receipt = await client.sendTransactionSync({
  to: tokenAddress,
  data: transferCalldata,
  validAfter: now,
  validBefore: now + 86_400,
});

let now = SystemTime::now()
    .duration_since(UNIX_EPOCH)?
    .as_secs();
 
let tx = TempoTransactionRequest {
    calls,
    valid_after: Some(now),
    valid_before: Some(now + 86_400),
    ..Default::default()
};
 
provider.send_transaction(tx).await?;

VALID_AFTER=$(($(date +%s) + 5))
VALID_BEFORE=$(($(date +%s) + 25))
 
cast erc20 transfer "$TOKEN" "$RECIPIENT" 100000000 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY" \
  --tempo.expiring-nonce \
  --tempo.valid-after "$VALID_AFTER" \
  --tempo.valid-before "$VALID_BEFORE"

Tempo Transactions FAQ.

The main mechanics behind native payment transactions, from stablecoin fees to delegated signing.

A Tempo Transaction is the native transaction type for payments on Tempo. It combines batching, fee tokens, fee sponsorship, scheduling, access keys, and nonce keys without requiring separate paymasters, relayers, or account layers.