Engineered for payments from the ground up

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

Base network fee for a standard stablecoin transfer.

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