DocsGuides, references & quickstart

Use Tempo with AI

Tempo MCP serverGive agents search and read tools for Tempo docs

Tempo pluginInstall MCP, workflow skills, and editor metadata

Tempo Docs skillAdd docs, examples, and source context

Tempo Transactions TIP-20 tokens

Docs Tempo Wallet Faucet TIDX Tempo Explorer Wallet CLI MPP SDKs

Performance Blog Docs

Tempo MCP serverGive agents search and read tools for Tempo docs

Tempo pluginInstall MCP, workflow skills, and editor metadata

Tempo Docs skillAdd docs, examples, and source context

Build on the blockchain engineered for payments

Accept payments, issue stablecoins, and build blockchain applications that scale globally from day one.

Stablecoin-native tokens.

Explore TIP-20 Create a stablecoin

stablecoin-swap

import { parseUnits } from "viem";
import { client } from "./viem.config";
 
const usdc = "0x20c0000000000000000000000000000000000001";
const usdt = "0x20c0000000000000000000000000000000000002";
const amountIn = parseUnits("100", 6);
const minAmountOut = parseUnits("99.50", 6);
 
const { receipt } = await client.dex.sellSync({
  tokenIn: usdc,
  tokenOut: usdt,
  amountIn,
  minAmountOut,
});

IStablecoinDex dex = IStablecoinDex(
    0xdec0000000000000000000000000000000000000
);
 
uint128 amountIn = 100e6;
uint128 quote = dex.quoteSwapExactAmountIn(
    USDC,
    USDT,
    amountIn
);
 
uint128 minOut = (quote * 995) / 1000;
uint128 amountOut = dex.swapExactAmountIn(
    USDC,
    USDT,
    amountIn,
    minOut
);

DEX=0xdec0000000000000000000000000000000000000
AMOUNT_IN=100000000
MIN_USDT_OUT=99500000
 
cast send "$DEX" \
  "swapExactAmountIn(address,address,uint128,uint128)(uint128)" \
  "$USDC" "$USDT" "$AMOUNT_IN" "$MIN_USDT_OUT" \
  --tempo.fee-token "$USDC" \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"

policy

import { client } from "./tempo";
 
// One registry entry, enforced on every transfer
const { policyId } = await client.policy.createSync({
  type: "blacklist",
  addresses: [blocked],
});
 
await client.token.changeTransferPolicySync({
  token: demoUsd,
  policyId,
});

use tempo_alloy::contracts::precompiles::{ITIP20, ITIP403Registry};
 
let registry = ITIP403Registry::new(TIP403_REGISTRY, provider);
let policy_id = registry
    .createPolicyWithAccounts(admin, PolicyType::BLACKLIST, vec![blocked])
    .send()
    .await?;
 
let token = ITIP20::new(demo_usd, provider);
token.changeTransferPolicyId(policy_id).send().await?;

cast send 0x403c000000000000000000000000000000000000 \
  "createPolicyWithAccounts(address,uint8,address[])" \
  "$ADMIN" 1 "[$BLOCKED]" \
  --tempo.fee-token 0x20c0000000000000000000000000000000000001 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"
 
cast send "$DEMO_USD" "changeTransferPolicyId(uint64)" "$POLICY_ID" \
  --tempo.fee-token 0x20c0000000000000000000000000000000000001 \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"

memo

import { parseUnits, stringToHex, pad } from "viem";
import { client } from "./tempo";
 
// A 32-byte reference travels with the transfer
const memo = pad(stringToHex("INV-12345"), { size: 32 });
 
const { receipt } = await client.token.transferSync({
  token: demoUsd,
  to: merchant,
  amount: parseUnits("125", 6),
  memo,
});

use alloy::primitives::{B256, U256};
use tempo_alloy::contracts::precompiles::ITIP20;
 
let memo = B256::right_padding_from(b"INV-12345");
let token = ITIP20::new(demo_usd, provider);
 
token
    .transferWithMemo(merchant, U256::from(125_000_000), memo)
    .send()
    .await?;

MEMO=$(cast format-bytes32-string "INV-12345")
 
cast send "$DEMO_USD" \
  "transferWithMemo(address,uint256,bytes32)" \
  "$MERCHANT" 125000000 "$MEMO" \
  --rpc-url "$TEMPO_RPC_URL" \
  --private-key "$PRIVATE_KEY"

Flexible fees for apps using stablecoins.

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-lane.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.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"

Pushing the frontier of blockchain performance.

Explore performance

Fast, guaranteed settlement

508 ms

Average time between finalized blocks in the latest benchmark data.

High throughput

21,200 TPS

Settled transfers per second measured during benchmark runs.

Predictably low fees

<$0.001

Average fee for standard stablecoin transfers.

Reliable uptime guarantees

99.999%

Network availability target for production payment workloads.

Open source

All of Tempo's code is open source, built by the same team behind Reth, Foundry, viem, and more.

View on GitHub

Dive deeper into Tempo's engineering

Engineering deep dives, network upgrades, events, and case studies from the team building Tempo.

Human Authorization in Agentic Workflows

How Tempo enables AI-accelerated development securely

Aug 17, 2026

View all blogs