frxUSD on Tempo

frxUSD is the first stablecoin to implement Tempo's TIP-20 standard (opens in a new tab) with full support for stablecoin-denominated gas payments and cross-chain supply tracking.

Tempo is a Frax Mesh spoke in the Fraxtal hub model. All five Frax assets (frxUSD, sfrxUSD, frxETH, sfrxETH, WFRAX) are live and wired to Fraxtal, and HopV2 relays Tempo to every other mesh chain through Fraxtal.

For details on the TIP-20 standard itself, see Tempo's official documentation (opens in a new tab).

Network Constants

Tempo has no native gas token. Its LayerZero endpoint is EndpointV2Alt, which charges messaging fees in LZEndpointDollar, an ERC-20 that wraps a whitelist of Tempo stablecoins. Every Frax contract on Tempo therefore rejects msg.value and collects fees through ERC-20 approvals instead (see Stablecoin-Denominated Gas).

Contract Addresses

Mainnet

All OFTs and the hop share their addresses with Somnia and Robinhood (deterministic 0x000000... deployment); see Addresses for the full crosschain matrix.

frxUSD is the only Frax asset on Tempo that is a native TIP-20 token. Users hold the TIP-20 at 0x20C0...f3c2, and the adapter at 0x00000000D617...f1E5 mints and burns it. The other four assets are standard ERC-20 OFTs with 18 decimals.

An FPI OFT also exists at 0x00000000bC4aEF4bA6363a437455Cb1af19e2aEb, but it is not connected to the mesh. FPI was retired before Tempo was wired, so this contract has no peers and cannot bridge.

Testnet (Moderato)

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                      TEMPO PRECOMPILES                          │
├─────────────────┬─────────────────┬─────────────────────────────┤
│ TIP403_REGISTRY │ STABLECOIN_DEX  │ TIP_FEE_MANAGER             │
│ Policy control  │ Token swaps     │ User gas preferences        │
└────────┬────────┴────────┬────────┴──────────────┬──────────────┘
         │                 │                       │
         ▼                 ▼                       ▼
┌─────────────────────────────────────────────────────────────────┐
│                    FRAX CONTRACTS                               │
├─────────────────────────────────────────────────────────────────┤
│ FrxUSDPolicyAdminTempo      - Freeze/thaw via TIP-403           │
│ FraxOFTMintableAdapterTIP20 - frxUSD bridge (mint/burn TIP-20)  │
│ FraxOFTUpgradeableTempo     - OFTs with stablecoin gas payment  │
│ RemoteHopV201Tempo          - HopV2 routing via Fraxtal         │
│ TempoFeeInclusiveWrapper    - Single-approval frxUSD bridging   │
└─────────────────────────────────────────────────────────────────┘

Routing Model

• Fraxtal is the hub chain for Tempo.
• Tempo -> Fraxtal and Fraxtal -> Tempo are direct OFT routes for all five assets.
• Tempo -> any other mesh chain relays through Fraxtal with HopV2 (RemoteHopV201Tempo on Tempo, FraxtalHopV2 at 0x00000000e18aFc20Afe54d4B2C8688bB60c06B36 on Fraxtal).
• Cross-chain stake/unstake and mint/redeem hops are not available on Tempo. Those hops pay fees in native msg.value, which EndpointV2Alt does not support.

LayerZero Configuration

The Tempo ↔ Fraxtal pathway uses the same five required DVNs as the rest of the mesh (LayerZero Labs, Horizen, Nethermind, Canary, Frax). Two settings are specific to Tempo (see Configuration for the full mesh settings):

Deliveries on Tempo use more gas than on other EVM chains, so Frax enforces a higher minimum for them. Messages from Tempo to Fraxtal carry the standard 200,000 / 250,000 gas.

Key Features

Stablecoin-Denominated Gas

Users pay bridge fees in their preferred Tempo stablecoin. The OFTs and the hop automatically:

1. Resolve the caller's fee token via TIP_FEE_MANAGER.userTokens(caller), falling back to PATH_USD when none is set.
2. If that token is on the LZEndpointDollar whitelist (currently PATH_USD, USDC.e and USDT0), pull the fee in that token and wrap it directly.
3. Otherwise (frxUSD included), swap it through STABLECOIN_DEX into whichever whitelisted token is cheapest to buy, then wrap.

Users never need a native gas token to bridge. If no whitelisted token can be bought with the caller's fee token, quoting and sending revert with NoSwappableWhitelistedToken.

Cross-Chain Supply Tracking

The frxUSD adapter includes SupplyTrackingModule, which records every frxUSD flow between Tempo and each peer chain:

// Outflows: frxUSD sent from Tempo to `_eid`
function totalTransferTo(uint32 _eid) external view returns (uint256);
// Inflows: frxUSD received on Tempo from `_eid`
function totalTransferFrom(uint32 _eid) external view returns (uint256);
 
// initialTotalSupply(_eid) + totalTransferTo(_eid) - totalTransferFrom(_eid)
function totalSupply(uint32 _eid) external view returns (uint256);

totalSupply(_eid) is only meaningful once governance has set initialTotalSupply(_eid). Until then it reverts with an arithmetic underflow whenever inflows from that chain exceed outflows, which is the case for Fraxtal today. Use totalTransferTo and totalTransferFrom directly for analytics.

TIP-403 Policy Compliance

Transfer restrictions on frxUSD are enforced at the protocol level via Tempo's TIP-403 Registry (opens in a new tab). frxUSD uses a blacklist policy (ID 5) administered by FrxUSDPolicyAdminTempo:

function freeze(address account) external;   // Owner or freezer: block account transfers
function thaw(address account) external;     // Owner only: unblock account
function isFrozen(address account) external view returns (bool);

Integration Guide

All amounts for frxUSD on Tempo use 6 decimals, and the adapter's decimalConversionRate is 1, so no dust is removed. The other four OFTs use 18 decimals and drop dust below 1e12, as on every other chain.

Quoting Bridge Fees

quoteSend() returns fee.nativeFee in LZEndpointDollar units, not in the user's token. Convert it with quoteUserTokenFee() to get the amount to approve:

import { SendParam, MessagingFee, IOFT } from "@fraxfinance/layerzero-v2-upgradeable/oapp/contracts/oft/interfaces/IOFT.sol";
import { OptionsBuilder } from "@fraxfinance/layerzero-v2-upgradeable/oapp/contracts/oapp/libs/OptionsBuilder.sol";
 
address oft = 0x00000000D61733e7A393A10A5B48c311AbE8f1E5; // frxUSD adapter on Tempo
address frxUSD = 0x20C0000000000000000000003554d28269E0f3c2;
uint32 dstEid = 30255; // Fraxtal
uint256 amount = 100e6; // 100 frxUSD (6 decimals)
 
SendParam memory sendParam = SendParam({
    dstEid: dstEid,
    to: bytes32(uint256(uint160(msg.sender))),
    amountLD: amount,
    minAmountLD: amount,
    extraOptions: OptionsBuilder.newOptions(),
    composeMsg: '',
    oftCmd: ''
});
 
// Fee in LZEndpointDollar units
MessagingFee memory fee = IOFT(oft).quoteSend(sendParam, false);
 
// The caller's fee token (PATH_USD if they never set one)
address feeToken = ITIPFeeManager(0xfeEC000000000000000000000000000000000000).userTokens(msg.sender);
if (feeToken == address(0)) feeToken = 0x20C0000000000000000000000000000000000000;
 
// Amount of feeToken that will actually be pulled
uint256 feeInToken = ITempoOFT(oft).quoteUserTokenFee(feeToken, fee.nativeFee);

For a whitelisted fee token, feeInToken == fee.nativeFee. For any other token, it is the StablecoinDEX exact-out quote at the time of the call.

Sending Cross-Chain

Tempo OFTs revert on any msg.value. Approve the fee token instead, and pass the unmodified fee from quoteSend():

// 1. Approve the bridged token (frxUSD adapter only: it burns the TIP-20 from the caller)
IERC20(frxUSD).approve(oft, amount);
 
// 2. Approve the fee token. If it is the same token as step 1, approve the sum instead.
IERC20(feeToken).approve(oft, feeInToken);
 
// 3. Send WITHOUT msg.value
IOFT(oft).send(sendParam, fee, payable(msg.sender));

If the user's fee token is frxUSD, approve amount + feeInToken in a single call. A DEX-routed fee can move between quote and send, so leave a small buffer on the fee approval.

Sending Beyond Fraxtal (HopV2)

To reach any chain other than Fraxtal in one transaction, call RemoteHopV201Tempo. As on other chains, the hop pulls the underlying token (IOFT(oft).token()), so approve that, not the OFT. Its fee functions follow the same split as the OFTs:

address hop = 0x0000006D38568b00B457580b734e0076C62de659;
bytes32 recipient = bytes32(uint256(uint160(msg.sender)));
uint32 dstEid = 30110; // Arbitrum, relayed via Fraxtal
 
uint256 feeInToken = IRemoteHopV201Tempo(hop).quoteStatic(oft, dstEid, recipient, amount, 0, "", feeToken);
 
IERC20(frxUSD).approve(hop, feeToken == frxUSD ? amount + feeInToken : amount);
if (feeToken != frxUSD) IERC20(feeToken).approve(hop, feeInToken);
 
IRemoteHopV201Tempo(hop).sendOFT(oft, dstEid, recipient, amount, 0, "");

Check that recipient is not zero before calling: a zero recipient is accepted on Tempo and the funds can only be recovered by governance on the destination.

Fee-Inclusive frxUSD Bridging

TempoFeeInclusiveWrapper lets an integrator bridge frxUSD with a single approval of frxUSD. The fee is quoted in frxUSD, deducted from the caller's budget, and only the net remainder is bridged. It is immutable, ownerless, and supports frxUSD plain transfers only; compose data is rejected.

address wrapper = 0x4877c528468a64FD5Fba87dDefd517dca72814a3;
 
// Preview: feeToken is frxUSD, netAmount is what will be bridged
(address feeToken, uint256 feeAmount, uint256 netAmount) =
    IWrapper(wrapper).quoteFeeInclusive(oft, dstEid, recipient, budget, 0, "");
 
IERC20(frxUSD).approve(wrapper, budget);
 
// minNetAmount must be non-zero: derive it from netAmount less your slippage tolerance
IWrapper(wrapper).sendOFTFeeInclusive(oft, dstEid, recipient, budget, minNetAmount, 0, "");

Contract Reference

FraxOFTUpgradeableTempo / FraxOFTMintableAdapterUpgradeableTIP20

FraxOFTMintableAdapterUpgradeableTIP20 (supply tracking)

FrxUSDPolicyAdminTempo

RemoteHopV201Tempo

TempoFeeInclusiveWrapper

Events

Supply Tracking

event AddToTotalTransferFromEid(uint32 indexed eid, uint256 previousAmount, uint256 amount);
event AddToTotalTransferFromSum(uint256 previousAmount, uint256 amount);
event AddToTotalTransferToEid(uint32 indexed eid, uint256 previousAmount, uint256 amount);
event AddToTotalTransferToSum(uint256 previousAmount, uint256 amount);
event SetInitialTotalSupply(uint32 indexed eid, uint256 amount);

Policy

event AccountFrozen(address indexed account);
event AccountThawed(address indexed account);
event AddFreezer(address indexed account);
event RemoveFreezer(address indexed account);
event PolicyIdSet(uint64 indexed policyId);

Source Code

• Tempo Integration Specs (opens in a new tab)
• FraxOFTUpgradeableTempo (opens in a new tab)
• FraxOFTMintableAdapterUpgradeableTIP20 (opens in a new tab)
• TempoAltTokenBase (opens in a new tab)
• SupplyTrackingModule (opens in a new tab)
• FrxUSDPolicyAdminTempo (opens in a new tab)
• RemoteHopV201Tempo (opens in a new tab)
• HopV201Tempo (opens in a new tab)
• TempoGasTokenBase (opens in a new tab)
• TempoFeeInclusiveWrapper (verified source) (opens in a new tab)