SfrxUSD

Fraxtal ERC-20 Token Browse chains

0xfc00000000000000000000000000000000000008

Proxy implementation: 0xba026e978eb1b11d72adabf33b7cf6f3e321ca83

Solidity v0.8.30+commit.73712a01

Fungible token following the ERC-20 standard.

🤖

Query this contract from your AI

Reference: 0xfc00000000000000000000000000000000000008

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

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 address of the bridge contract used by this token.✨ AI

Returns

Name	Type	Description
—	address	The bridge contract address used for token bridging and cross-chain operations.✨ AI

DOMAIN_SEPARATOR() view

Returns the EIP-712 domain separator used for signing and verifying structured data.✨ AI

Returns

Name	Type	Description
—	bytes32	The EIP-712 domain separator as a bytes32 value, used to scope and prevent replay of off-chain signatures.✨ AI

REMOTE_TOKEN() view

Returns the address of the remote token associated with this SfrxUSD contract.✨ AI

Returns

Name	Type	Description
—	address	The address of the remote token contract that this SfrxUSD token represents or is linked to.✨ AI

allowance(owner: address, spender: address) view

Returns the remaining number of tokens that spender is allowed to spend on behalf of owner.✨ AI

dev: See {IERC20-allowance}.

Parameters

Name	Type	Description
owner	address	Token owner address whose allowance is being queried.✨ AI
spender	address	Address permitted to spend tokens from the owner's balance.✨ AI

Returns

Name	Type	Description
—	uint256	Remaining allowance as a uint256 in the token's smallest units that 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.✨ AI

dev: See {IERC20-balanceOf}.

Parameters

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

Returns

Name	Type	Description
—	uint256	The number of tokens owned by the specified account, expressed in the token's smallest unit.✨ 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 decimal places used by the token (uint8).✨ AI

eip712Domain() view

Returns the EIP-712 domain components used to verify signed typed data.✨ AI

dev: See {IERC-5267}.

Returns

Name	Type	Description
fields	bytes1	fields: single byte bitmask describing which EIP-712 domain fields are present.✨ AI
name	string	name: human-readable name of the signing domain (token or protocol).✨ AI
version	string	version: domain version string used for replay protection and upgrades.✨ AI
chainId	uint256	chainId: blockchain chain identifier used in the domain separation.✨ AI
verifyingContract	address	verifyingContract: contract address that verifies the signed typed data.✨ AI
salt	bytes32	salt: domain salt or unique bytes32 identifier used in domain separation.✨ AI
extensions	uint256[]	extensions: array of numeric domain extension values for future compatibility.✨ 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 a given 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, otherwise false.✨ AI

minters_array(uint256) view

Return the minter address at the specified index.✨ AI

Parameters

Name	Type	Description
—	uint256

Returns

Name	Type	Description
—	address	Minter address stored at the given index.✨ AI

name() view

Returns the token's name as a human-readable string.✨ AI

dev: Returns the name of the token.

Returns

Name	Type	Description
—	string	The ERC-20 token name string (for example: SfrxUSD).✨ AI

nominatedOwner() view

Get the address nominated to become the contract owner.✨ AI

Returns

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

nonces(owner: address) view

Return the current permit nonce for an address to prevent replay of off-chain permit signatures.✨ 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) that increments each time a permit signature is used.✨ AI

owner() view

Returns the address of the account that owns the contract.✨ AI

Returns

Name	Type	Description
—	address	Address of the contract owner with administrative privileges.✨ 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

Returns the token's short symbol used for display.✨ AI

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

Returns

Name	Type	Description
—	string	The ERC-20 token symbol string (e.g., sfrxUSD).✨ AI

timelock_address() view

Returns the timelock contract address used to manage administrative actions for this token.✨ AI

Returns

Name	Type	Description
—	address	The address of the timelock contract that holds administrative control over the token.✨ AI

totalSupply() view

Returns the total supply of SfrxUSD tokens.✨ AI

dev: See {IERC20-totalSupply}.

Returns

Name	Type	Description
—	uint256	The total number of SfrxUSD tokens in existence as a uint256, expressed in the token's smallest unit.✨ AI

version() pure

Getter for the semantic version of the contract. This is not meant to be used onchain but instead meant to be used by offchain tooling.

Returns

Name	Type	Description
—	string	Semver contract version as a string.

Write Functions

acceptOwnership() nonpayable

Allow the nominated owner to accept and become the contract owner.✨ 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

Allow a spender to transfer up to a specified number of 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 transfer tokens.✨ AI
value	uint256	Maximum token amount the spender is authorized to transfer.✨ AI

Returns

Name	Type	Description
—	bool	True if the approval succeeded; otherwise false.✨ 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 account using the caller's allowance and reduces total supply.✨ 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 tokens will be burned.✨ AI
value	uint256	Amount of tokens to burn, expressed in the token's smallest unit.✨ AI

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

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

Nominate a new owner candidate for the contract; the nominee must accept to become the actual owner.✨ AI

Parameters

Name	Type	Description
_owner	address	Address to nominate as the pending owner (the candidate must accept ownership).✨ AI

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

Allows an owner to set a spender's allowance using an off-chain signature (EIP-2612) without an on-chain approve call.✨ 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	Address of the token holder granting the allowance.✨ AI
spender	address	Address authorized to spend the owner's tokens.✨ AI
value	uint256	Allowance amount to set (in token smallest units).✨ AI
deadline	uint256	Unix timestamp after which the provided signature is invalid.✨ AI
signature	bytes

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

Allows an owner to set a spender's allowance using an off-chain signature (EIP-2612) without an on-chain approve call.✨ AI

Parameters

Name	Type	Description
owner	address	Address of the token holder granting the allowance.✨ AI
spender	address	Address authorized to spend the owner's tokens.✨ AI
value	uint256	Allowance amount to set (in token smallest units).✨ AI
deadline	uint256	Unix timestamp after which the provided signature is invalid.✨ AI
v	uint8	ECDSA recovery id component of the signature.✨ AI
r	bytes32	First 32-byte word of the ECDSA signature.✨ AI
s	bytes32	Second 32-byte word of the 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

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

transfer(to: address, value: uint256) nonpayable

Transfer tokens from your account to the specified 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 that will receive the tokens.✨ AI
value	uint256	Number of tokens to transfer, specified in the token's smallest unit.✨ AI

Returns

Name	Type	Description
—	bool	True if the transfer succeeded, otherwise false.✨ AI

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

Transfers tokens from one address to another using the caller's 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	Source address whose tokens will be transferred.✨ AI
to	address	Destination address that will receive the tokens.✨ AI
value	uint256	Amount of tokens to transfer, in the token's smallest unit.✨ AI

Returns

Name	Type	Description
—	bool	True if the transfer succeeded.✨ 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

Events

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

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