EVM Compatibility

// Standard Ethereum transaction
const ethTx = await wallet.sendTransaction({
  to: recipient,
  value: parseEther('1'),
});

// Tempo transaction with batching
const tempoTx = await wallet.sendTransaction({
  calls: [
    { to: recipient1, value: parseEther('1'), input: '0x' },
    { to: recipient2, value: parseEther('0.5'), input: '0x' },
  ],
});

// Ethereum (fees in ETH)
const ethTx = {
  maxFeePerGas: parseGwei('50'),        // 50 gwei in ETH
  maxPriorityFeePerGas: parseGwei('2'), // 2 gwei tip
};

// Tempo (fees in stablecoins, specified in attodollars)
const tempoTx = {
  maxFeePerGas: 20_000_000_000n,           // 20 billion attodollars/gas
  maxPriorityFeePerGas: 1_000_000_000n,    // 1 billion attodollars/gas
  feeToken: USDC_ADDRESS,                  // Optional: pay in specific token
};

function verifyTempoSignature(
    bytes32 hash,
    bytes memory signature,
    address signer
) public view returns (bool) {
    // Automatically handles secp256k1, P256, or WebAuthn
    // based on signature format
}

// Ethereum: ~7,200 blocks per day
// Tempo: ~172,800 blocks per day

function timeBasedLogic() public {
    // Use block.timestamp for time checks, not block.number
    require(block.timestamp >= unlockTime, "Too early");
}

// Ethereum: Wait for confirmations
const receipt = await tx.wait(5); // Wait 5 blocks (~1 min)

// Tempo: Single confirmation is final
const receipt = await tx.wait(1); // <1 second, irreversible

// High storage cost on Tempo
contract ManyMappings {
    mapping(address => uint256) public balances;        // 250k gas per new entry
    mapping(address => bool) public whitelist;          // 250k gas per new entry
    mapping(address => UserData) public userData;       // 250k per struct (per slot)
    
    // Cheaper: Use TIP-20 for balances (enshrined, optimized)
    ITIP20 public token; // Only 50k gas per transfer
}

# Foundry gas reports
forge test --gas-report --rpc-url https://rpc.moderato.tempo.xyz

// ❌ Avoid: Block numbers grow 24x faster on Tempo
require(block.number > unlockBlock, "Locked");

// ✅ Use timestamps instead
require(block.timestamp > unlockTime, "Locked");

// Ethereum gas estimation
const ethGas = await contract.estimateGas.myFunction();
const ethCost = ethGas * gasPrice; // in ETH

// Tempo gas estimation
const tempoGas = await contract.estimateGas.myFunction();
const tempoCost = tempoGas * baseFee; // in attodollars
const tempoCostUSD = tempoCost / 1e18; // convert to dollars

// Supports all Tempo signature types
import "@tempo/contracts/SignatureVerifier.sol";

contract MyContract is SignatureVerifier {
    function verifyUser(bytes32 hash, bytes memory sig, address user) public view {
        require(recoverSigner(hash, sig) == user, "Invalid signature");
    }
}

# Deploy to Tempo
forge create MyContract \
  --rpc-url https://rpc.moderato.tempo.xyz \
  --private-key $PRIVATE_KEY

# Run tests against Tempo fork
forge test --fork-url https://rpc.moderato.tempo.xyz

// hardhat.config.js
module.exports = {
  networks: {
    tempo: {
      url: 'https://rpc.moderato.tempo.xyz',
      chainId: 42431,
      accounts: [process.env.PRIVATE_KEY],
    },
  },
};

import { createPublicClient, http } from 'viem';

const client = createPublicClient({
  chain: {
    id: 42431,
    name: 'Tempo Testnet',
    network: 'tempo',
    nativeCurrency: { name: 'USD', symbol: 'USD', decimals: 6 },
    rpcUrls: {
      default: { http: ['https://rpc.moderato.tempo.xyz'] },
    },
  },
  transport: http(),
});

import Web3 from 'web3';

const web3 = new Web3('https://rpc.moderato.tempo.xyz');

// Fund address on testnet (faucet)
await provider.send('tempo_fundAddress', [address]);

// Get nonce for specific nonce key
const nonce = await provider.send('tempo_getNonce', [
  address,
  nonceKey, // U256 nonce key
]);

// Estimate gas for Tempo transaction
const gas = await provider.send('eth_estimateGas', [{
  calls: [/* batch calls */],
  nonceKey: '0x1',
}]);

interface TempoTransactionReceipt extends TransactionReceipt {
  feeToken?: string;          // Token used for fee payment
  feePayer?: string;          // Address that paid fees (if sponsored)
  batchIndex?: number;        // Index of call in batch
  subBlockIndex?: number;     // Sub-block index (if validator tx)
}