Build on the blockchain engineered for payments

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

Stablecoin-native tokens.

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: '0x20c0000000000000000000006a37da5c996874be',
});

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

15,600 TPS

Settled transactions per second in the latest multi-region benchmark.

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

Product announcements, engineering deep dives, network upgrades, events, and case studies from the team building Tempo.

Supercharge your agentic workflows with Mercator

A new effort option for agents: discover, price, and execute paid tool workflows through one interface.

Sep 23, 2026

View all blogs