FrxUSD

Fraxtal ERC-20 Token Browse chains

0xfc00000000000000000000000000000000000001

Proxy implementation: 0x0000000083bdf23788585d499eab0d92a8befb1d

Solidity v0.8.30+commit.73712a01

Fungible token following the ERC-20 standard.

🤖

Query this contract from your AI

Reference: 0xfc00000000000000000000000000000000000001

Sample prompt: "Tell me the current state of fraxtal/0xfc00000000000000000000000000000000000001"

No AI wired up yet? → mcp.smarts.md · Browse chains

Fraxtal is a docs-only chain on Smarts: source code and ABI are indexed, but live on-chain data (state, recent events, admin profile) is not currently available. AI agents can still query get_contract_info and get_contract_source via MCP.

Overview

Read Functions

Write Functions

Events

Read Functions

BRIDGE() view

Returns the bridge contract address used by FrxUSD for cross-chain bridging.✨ AI

Returns

Name	Type	Description
—	address	Address of the bridge contract that handles cross-chain deposits and withdrawals.✨ AI

DOMAIN_SEPARATOR() view

Retrieve the EIP-712 domain separator used for signing typed data.✨ AI

Returns

Name	Type	Description
—	bytes32	EIP-712 domain separator (bytes32) used for permit/typed-data signatures.✨ AI

REMOTE_TOKEN() view

Returns the address of the remote token contract linked to this FrxUSD token.✨ AI

Returns

Name	Type	Description
—	address	Address of the remote token contract associated with this FrxUSD token.✨ AI

allowance(owner: address, spender: address) view

Return the remaining number of tokens spender is allowed to transfer from owner.✨ AI

dev: See {IERC20-allowance}.

Parameters

Name	Type	Description
owner	address	Token holder address.✨ AI
spender	address	Address permitted to spend the holder's tokens.✨ AI

Returns

Name	Type	Description
—	uint256	Remaining allowance as a uint256 representing the number of tokens spender may transfer from owner.✨ AI

authorizationState(authorizer: address, nonce: bytes32) view

Returns the state of an authorization

dev: Nonces are randomly generated 32-byte data unique to the authorizer's address

Parameters

Name	Type	Description
authorizer	address	Authorizer's address
nonce	bytes32	Nonce of the authorization

Returns

Name	Type	Description
—	bool	True if the nonce is used

balanceOf(account: address) view

Returns the token balance of the specified account address.✨ AI

dev: See {IERC20-balanceOf}.

Parameters

Name	Type	Description
account	address	Address whose ERC-20 token balance will be returned.✨ AI

Returns

Name	Type	Description
—	uint256	The current token balance of the account as a uint256.✨ AI

bridge() view

Legacy getter for BRIDGE

Returns

Name	Type	Description
—	address	address The bridge address

decimals() view

Returns the number of decimal places the token uses.✨ AI

dev: Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5.05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the default value returned by this function, unless it's overridden. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.

Returns

Name	Type	Description
—	uint8	Number of decimals used by the token as an uint8 (e.g., 18).✨ AI

eip712Domain() view

Return the EIP-712 domain parameters that the token uses for typed-data signing.✨ AI

dev: See {IERC-5267}.

Returns

Name	Type	Description
fields	bytes1	Single-byte flags or reserved field for the domain (bytes1).✨ AI
name	string	Domain name string used in EIP-712 (token name).✨ AI
version	string	Domain version string used in EIP-712.✨ AI
chainId	uint256	Chain ID value for the EIP-712 domain.✨ AI
verifyingContract	address	Address used as verifyingContract in the EIP-712 domain.✨ AI
salt	bytes32	32-byte salt value included in the domain for uniqueness.✨ AI
extensions	uint256[]	Array of uint256 extension values for optional domain parameters.✨ AI

isFreezer(address) view

Checks whether the given address is a registered freezer.✨ AI

Parameters

Name	Type	Description
—	address

Returns

Name	Type	Description
—	bool	True if the address has freezer privileges, otherwise false.✨ AI

isFrozen(address) view

Returns true if the given address is frozen and cannot transfer or receive tokens.✨ AI

Parameters

Name	Type	Description
—	address

Returns

Name	Type	Description
—	bool	True if the address is frozen and barred from token transfers; otherwise false.✨ AI

isPaused() view

Returns true when the contract is paused, disabling transfers and other state-changing actions.✨ AI

Returns

Name	Type	Description
—	bool	True if the contract is paused; false if it is active and operations are allowed.✨ AI

l1Token() view

Legacy getter for the remote token. Use REMOTE_TOKEN going forward.

Returns

Name	Type	Description
—	address	address The L1 remote token address

l2Bridge() view

Legacy getter for the bridge. Use BRIDGE going forward.

Returns

Name	Type	Description
—	address	address The bridge address

minters(address) view

Check whether an address is authorized to mint new tokens.✨ AI

Parameters

Name	Type	Description
—	address

Returns

Name	Type	Description
—	bool	True if the address is an authorized minter, false otherwise.✨ AI

minters_array(uint256) view

Return the minter address stored at the specified index in the contract's minters list.✨ AI

Parameters

Name	Type	Description
—	uint256

Returns

Name	Type	Description
—	address	The address of the minter at the provided index.✨ AI

name() view

Returns the token name used in wallets and user interfaces.✨ AI

dev: Returns the name of the token.

Returns

Name	Type	Description
—	string	The token's human-readable name as a string, for example "FrxUSD".✨ AI

nominatedOwner() view

Shows the address currently nominated to become the contract owner.✨ AI

Returns

Name	Type	Description
—	address	The nominated owner address; returns the zero address if no nomination exists.✨ AI

nonces(owner: address) view

Returns the current permit nonce for an address.✨ AI

dev: Returns the current nonce for `owner`. This value must be included whenever a signature is generated for {permit}. Every successful call to {permit} increases ``owner``'s nonce by one. This prevents a signature from being used multiple times.

Parameters

Name	Type	Description
owner	address	Address whose permit nonce is returned.✨ AI

Returns

Name	Type	Description
—	uint256	Current nonce (uint256) for the owner, used to prevent replay of permit signatures.✨ AI

owner() view

Returns the address of the contract owner.✨ AI

Returns

Name	Type	Description
—	address	The address that currently holds owner privileges for this contract.✨ AI

remoteToken() view

Legacy getter for REMOTE_TOKEN

Returns

Name	Type	Description
—	address	address The L1 remote token address

supportsInterface(_interfaceId: bytes4) pure

ERC165 interface check function.

Parameters

Name	Type	Description
_interfaceId	bytes4	Interface ID to check.

Returns

Name	Type	Description
—	bool	Whether or not the interface is supported by this contract.

symbol() view

Get the ERC-20 token symbol for the FrxUSD token.✨ AI

dev: Returns the symbol of the token, usually a shorter version of the name.

Returns

Name	Type	Description
—	string	The token symbol as a string (human-readable, e.g. "frxUSD").✨ AI

timelock_address() view

Returns the timelock contract address used by the token for governance and time-delayed operations.✨ AI

Returns

Name	Type	Description
—	address	Address of the timelock contract that controls time-delayed governance actions.✨ AI

totalSupply() view

Returns the total number of frxUSD tokens in existence.✨ AI

dev: See {IERC20-totalSupply}.

Returns

Name	Type	Description
—	uint256	Total supply of frxUSD expressed in the token's smallest unit (uint256).✨ AI

version() pure

Upgrade version of the contract

dev: Does not impact EIP712 version, which is automatically set to "1" in constructor

Returns

Name	Type	Description
—	string

Write Functions

acceptOwnership() nonpayable

Allow the pending owner to accept and finalize the contract's ownership transfer.✨ AI

addFreezer(_freezer: address) nonpayable

Adds an address to the set of freezers that can freeze accounts.✨ AI

Parameters

Name	Type	Description
_freezer	address	Address to grant freezer privileges.✨ AI

addMinter(minter_address: address) nonpayable

Adds a non-bridge minter

Parameters

Name	Type	Description
minter_address	address	Address of minter to add

approve(spender: address, value: uint256) nonpayable

Approve spender to transfer up to value tokens from your account.✨ AI

dev: See {IERC20-approve}. NOTE: If `value` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.

Parameters

Name	Type	Description
spender	address	Address allowed to spend tokens.✨ AI
value	uint256	Maximum token amount the spender is allowed to transfer.✨ AI

Returns

Name	Type	Description
—	bool	True if the approval succeeded.✨ AI

burn(value: uint256) nonpayable

Allows the StandardBridge on this network to burn tokens.

Parameters

Name	Type	Description
value	uint256

burn(_from: address, _amount: uint256) nonpayable

Allows the StandardBridge on this network to burn tokens.

Parameters

Name	Type	Description
_from	address	Address to burn tokens from.
_amount	uint256	Amount of tokens to burn.

burnFrom(account: address, value: uint256) nonpayable

Burns tokens from an account using the caller's allowance.✨ AI

dev: Destroys a `value` amount of tokens from `account`, deducting from the caller's allowance. See {ERC20-_burn} and {ERC20-allowance}. Requirements: - the caller must have allowance for ``accounts``'s tokens of at least `value`.

Parameters

Name	Type	Description
account	address	Address whose balance will be reduced.✨ AI
value	uint256	Amount of tokens to burn, in the token's smallest unit.✨ AI

burnFrxUsd(_owner: address, _amount: uint256) nonpayable

External admin gated function to burn balance from a given account

dev: if `_amount` == 0, entire balance will be burned

Parameters

Name	Type	Description
_owner	address	The account whose balance will be burned
_amount	uint256	The amount of balance to burn

burnMany(_owners: address[], _amounts: uint256[]) nonpayable

External admin gated function to batch burn balance from a set of accounts

dev: if `_amount` == 0, entire balance will be burned

Parameters

Name	Type	Description
_owners	address[]	Array of accounts whose balances will be burned
_amounts	uint256[]	Array of amounts corresponding to the balances to be burned

cancelAuthorization(authorizer: address, nonce: bytes32, v: uint8, r: bytes32, s: bytes32) nonpayable

The ```cancelAuthorization``` function cancels an authorization nonce

dev: EOA wallet signatures should be packed in the order of r, s, v

Parameters

Name	Type	Description
authorizer	address	Authorizer's address
nonce	bytes32	Nonce of the authorization
v	uint8	ECDSA signature v value
r	bytes32	ECDSA signature r value
s	bytes32	ECDSA signature s value

cancelAuthorization(authorizer: address, nonce: bytes32, signature: bytes) nonpayable

The ```cancelAuthorization``` function cancels an authorization nonce

dev: EOA wallet signatures should be packed in the order of r, s, v

Parameters

Name	Type	Description
authorizer	address	Authorizer's address
nonce	bytes32	Nonce of the authorization
signature	bytes

freeze(_owner: address) nonpayable

External admin gated function to freeze a given account

Parameters

Name	Type	Description
_owner	address	The account to be frozen

freezeMany(_owners: address[]) nonpayable

External admin gated function to batch freeze a set of accounts

Parameters

Name	Type	Description
_owners	address[]	Array of accounts to be frozen

mint(_to: address, _amount: uint256) nonpayable

Allows the StandardBridge on this network to mint tokens.

Parameters

Name	Type	Description
_to	address	Address to mint tokens to.
_amount	uint256	Amount of tokens to mint.

minter_burn_from(b_address: address, b_amount: uint256) nonpayable

Used by non-bridge minters to burn tokens

Parameters

Name	Type	Description
b_address	address	Address of the account to burn from
b_amount	uint256	Amount of tokens to burn

minter_mint(m_address: address, m_amount: uint256) nonpayable

Used by non-bridge minters to mint new tokens

Parameters

Name	Type	Description
m_address	address	Address of the account to mint to
m_amount	uint256	Amount of tokens to mint

nominateNewOwner(_owner: address) nonpayable

Proposes a new owner for the contract by nominating the specified address.✨ AI

Parameters

Name	Type	Description
_owner	address	Address being nominated to become the contract owner; nominee must accept ownership separately.✨ AI

pause() nonpayable

External admin gated pause function

permit(owner: address, spender: address, value: uint256, deadline: uint256, signature: bytes) nonpayable

Allow a spender to spend the owner's tokens using an off-chain EIP-2612 signature.✨ AI

dev: Sets `value` as the allowance of `spender` over ``owner``'s tokens, given ``owner``'s signed approval. IMPORTANT: The same issues {IERC20-approve} has related to transaction ordering also apply here. Emits an {Approval} event. Requirements: - `spender` cannot be the zero address. - `deadline` must be a timestamp in the future. - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` over the EIP712-formatted function arguments. - the signature must use ``owner``'s current nonce (see {nonces}). For more information on the signature format, see the https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP section]. CAUTION: See Security Considerations above.

Parameters

Name	Type	Description
owner	address	Token holder whose approval is being granted.✨ AI
spender	address	Address being approved to transfer the owner's tokens.✨ AI
value	uint256	Amount of tokens the spender is allowed to transfer.✨ AI
deadline	uint256	Unix timestamp after which the permit signature is no longer valid.✨ AI
signature	bytes

permit(owner: address, spender: address, value: uint256, deadline: uint256, v: uint8, r: bytes32, s: bytes32) nonpayable

Allow a spender to spend the owner's tokens using an off-chain EIP-2612 signature.✨ AI

Parameters

Name	Type	Description
owner	address	Token holder whose approval is being granted.✨ AI
spender	address	Address being approved to transfer the owner's tokens.✨ AI
value	uint256	Amount of tokens the spender is allowed to transfer.✨ AI
deadline	uint256	Unix timestamp after which the permit signature is no longer valid.✨ AI
v	uint8	ECDSA signature recovery byte (part of the owner's signature).✨ AI
r	bytes32	First 32 bytes of the owner's ECDSA signature.✨ AI
s	bytes32	Second 32 bytes of the owner's ECDSA signature.✨ AI

receiveWithAuthorization(from: address, to: address, value: uint256, validAfter: uint256, validBefore: uint256, nonce: bytes32, signature: bytes) nonpayable

The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer

dev: EOA wallet signatures should be packed in the order of r, s, v

Parameters

Name	Type	Description
from	address	Payer's address (Authorizer)
to	address	Payee's address
value	uint256	Amount to be transferred
validAfter	uint256	The block.timestamp after which the authorization is valid
validBefore	uint256	The block.timestamp before which the authorization is valid
nonce	bytes32	Unique nonce
signature	bytes

receiveWithAuthorization(from: address, to: address, value: uint256, validAfter: uint256, validBefore: uint256, nonce: bytes32, v: uint8, r: bytes32, s: bytes32) nonpayable

The ```receiveWithAuthorization``` function receives a transfer with a signed authorization from the payer

dev: EOA wallet signatures should be packed in the order of r, s, v

Parameters

Name	Type	Description
from	address	Payer's address (Authorizer)
to	address	Payee's address
value	uint256	Amount to be transferred
validAfter	uint256	The block.timestamp after which the authorization is valid
validBefore	uint256	The block.timestamp before which the authorization is valid
nonce	bytes32	Unique nonce
v	uint8	ECDSA signature parameter v
r	bytes32	ECDSA signature parameters r
s	bytes32	ECDSA signature parameters s

removeFreezer(_freezer: address) nonpayable

Remove a freezer address, revoking its ability to freeze tokens.✨ AI

Parameters

Name	Type	Description
_freezer	address	Address to revoke freezer privileges from.✨ AI

removeMinter(minter_address: address) nonpayable

Removes a non-bridge minter

Parameters

Name	Type	Description
minter_address	address	Address of minter to remove

setTimelock(_timelock_address: address) nonpayable

Sets the timelock address

Parameters

Name	Type	Description
_timelock_address	address	Address of the timelock

thaw(_owner: address) nonpayable

External admin gated function to unfreeze an account

Parameters

Name	Type	Description
_owner	address	The account to be unfrozen

thawMany(_owners: address[]) nonpayable

External admin gated function to unfreeze a set of accounts

Parameters

Name	Type	Description
_owners	address[]	Array of accounts to be unfrozen

transfer(to: address, value: uint256) nonpayable

Transfer a specified amount of tokens from the caller to the given address.✨ AI

dev: See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `value`.

Parameters

Name	Type	Description
to	address	Recipient address to receive the tokens.✨ AI
value	uint256	Amount of tokens to transfer, specified in the token's smallest unit.✨ AI

Returns

Name	Type	Description
—	bool	True if the transfer succeeded and was recorded.✨ AI

transferFrom(from: address, to: address, value: uint256) nonpayable

Transfers tokens from 'from' to 'to' using the caller's approved allowance.✨ AI

dev: See {IERC20-transferFrom}. Skips emitting an {Approval} event indicating an allowance update. This is not required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve]. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `value`. - the caller must have allowance for ``from``'s tokens of at least `value`.

Parameters

Name	Type	Description
from	address	Address to debit tokens from.✨ AI
to	address	Address to credit tokens to.✨ AI
value	uint256	Amount of tokens to transfer, denominated in the token's smallest unit.✨ AI

Returns

Name	Type	Description
—	bool	True if the transfer succeeds.✨ AI

transferWithAuthorization(from: address, to: address, value: uint256, validAfter: uint256, validBefore: uint256, nonce: bytes32, signature: bytes) nonpayable

The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009

dev: added in v1.1.0

Parameters

Name	Type	Description
from	address	Payer's address (Authorizer)
to	address	Payee's address
value	uint256	Amount to be transferred
validAfter	uint256	The block.timestamp after which the authorization is valid
validBefore	uint256	The block.timestamp before which the authorization is valid
nonce	bytes32	Unique nonce
signature	bytes

transferWithAuthorization(from: address, to: address, value: uint256, validAfter: uint256, validBefore: uint256, nonce: bytes32, v: uint8, r: bytes32, s: bytes32) nonpayable

The ```transferWithAuthorization``` function executes a transfer with a signed authorization according to Eip3009

dev: added in v1.1.0

Parameters

Name	Type	Description
from	address	Payer's address (Authorizer)
to	address	Payee's address
value	uint256	Amount to be transferred
validAfter	uint256	The block.timestamp after which the authorization is valid
validBefore	uint256	The block.timestamp before which the authorization is valid
nonce	bytes32	Unique nonce
v	uint8	ECDSA signature parameter v
r	bytes32	ECDSA signature parameters r
s	bytes32	ECDSA signature parameters s

unpause() nonpayable

External admin gated unpause function

Events

AccountFrozen(account: address)

Event Emitted when an address is frozen

Name	Type	Indexed	Description
account	address		The account being frozen

AccountThawed(account: address)

Event Emitted when an address is unfrozen

Name	Type	Indexed	Description
account	address		The account being thawed

AddFreezer(account: address)

Event Emitted when an address is added as a freezer

Name	Type	Indexed	Description
account	address		The account being added as a freezer

Approval(owner: address, spender: address, value: uint256)

Name	Type	Indexed
owner	address	✓
spender	address	✓
value	uint256

AuthorizationCanceled(authorizer: address, nonce: bytes32)

```AuthorizationCanceled``` event is emitted when an authorization is canceled

Name	Type	Indexed	Description
authorizer	address	✓	Authorizer's address
nonce	bytes32	✓	Nonce of the authorization

AuthorizationUsed(authorizer: address, nonce: bytes32)

```AuthorizationUsed``` event is emitted when an authorization is used

Name	Type	Indexed	Description
authorizer	address	✓	Authorizer's address
nonce	bytes32	✓	Nonce of the authorization

Burn(account: address, amount: uint256)

Emitted whenever the bridge burns tokens from an account

Name	Type	Indexed	Description
account	address	✓	Address of the account tokens are being burned from
amount	uint256		Amount of tokens burned

EIP712DomainChanged()

Mint(account: address, amount: uint256)

Emitted whenever the bridge mints tokens to an account

Name	Type	Indexed	Description
account	address	✓	Address of the account tokens are being minted for
amount	uint256		Amount of tokens minted.

MinterAdded(minter_address: address)

Emitted when a non-bridge minter is added

Name	Type	Indexed	Description
minter_address	address		Address of the new minter

MinterRemoved(minter_address: address)

Emitted when a non-bridge minter is removed

Name	Type	Indexed	Description
minter_address	address		Address of the removed minter

OwnerChanged(oldOwner: address, newOwner: address)

Name	Type	Indexed	Description
oldOwner	address
newOwner	address

OwnerNominated(newOwner: address)

Name	Type	Indexed	Description
newOwner	address

Paused()

Event Emitted when the contract is paused

RemoveFreezer(account: address)

Event Emitted when an address is removed as a freezer

Name	Type	Indexed	Description
account	address		The account being removed as a freezer

TimelockChanged(timelock_address: address)

Emitted when the timelock address changes

Name	Type	Indexed	Description
timelock_address	address		Address of the removed timelock

TokenMinterBurned(from: address, to: address, amount: uint256)

Emitted when a non-bridge minter burns tokens

Name	Type	Indexed	Description
from	address	✓	The account whose tokens are burned
to	address	✓	The minter doing the burning
amount	uint256		Amount of tokens burned

TokenMinterMinted(from: address, to: address, amount: uint256)

Emitted when a non-bridge minter mints tokens

Name	Type	Indexed	Description
from	address	✓	The minter doing the minting
to	address	✓	The account that gets the newly minted tokens
amount	uint256		Amount of tokens minted

Transfer(from: address, to: address, value: uint256)

Name	Type	Indexed
from	address	✓
to	address	✓
value	uint256

Unpaused()

Event Emitted when the contract is unpaused