Haycen

We express our gratitude to the Haycen team for the collaborative engagement that enabled the execution of this Smart Contract Security Assessment.

The FiatTokenV3 contract is an upgradable ERC-20 token built for fiat-backed stablecoins, with compliance features like blacklisting, pausability, and meta-transaction support. Minting and burning are tightly controlled: only approved minters with assigned allowances can mint, and they can burn tokens from their own balance to reduce supply.

The system users should acknowledge all the risks summed up in the risks section of the report

Documentation quality

• Functional requirements are detailed.

• • Project overview is detailed.

  • All roles in the system are described.

  • All interactions are described.

  • For each contract all futures are described.

• Technical description is robust.

• • Run instructions are provided.

  • Technical specification is provided.

  • NatSpec covers the code and is excellent.

Code quality

• Development environment is configured.

Test coverage

Code coverage of the project is 95.26% (branch coverage).

• Deployment and basic user interactions are covered with tests.

The FiatTokenV3 contract is an upgradable ERC-20 token built for fiat-backed stablecoins, with compliance features like blacklisting, pausability, and meta-transaction support. Minting and burning are tightly controlled: only approved minters with assigned allowances can mint, and they can burn tokens from their own balance to reduce supply. Roles such as pauser, blacklister, and master minter enable centralized governance and emergency controls. This design ensures secure, permissioned issuance and transfer of stablecoins within regulatory frameworks.

This Ownable contract implements a basic ownership access control mechanism, allowing a single address to be designated as the owner with exclusive permission to perform restricted operations. Ownership can be transferred to another address through an externally accessible function, with safeguards against assigning ownership to the zero address. The initial owner is set during deployment, and ownership changes are recorded via emitted events.

This Pausable contract implements an emergency stop mechanism, allowing designated addresses to pause and unpause contract operations through controlled state transitions. A distinct pauser role is assigned and can be updated by the owner, with checks preventing assignment to the zero address. Functions guarded by the whenNotPaused modifier enforce conditional execution based on the contract’s paused state.

The Controller contract implements an owner-controller-worker access model, where the owner assigns a unique worker to each controller address. Controller-to-worker relationships are maintained in a mapping and can be configured or disabled by the owner. Execution of certain functions is restricted to controllers with active worker assignments.

The MintController contract extends the Controller contract to manage minting permissions through a controller-minter model. Controllers, once configured by the owner, are permitted to manage a single associated minter by configuring, removing, or adjusting its minting allowance via interactions with a MinterManagementInterface implementation. The minter address must be active to permit allowance changes, and each controller's permissions are limited to a single minter, while the same minter can be shared across multiple controllers.

The Rescuable contract allows controlled recovery of ERC20 tokens from the contract by a designated rescuer address. The rescuer can be updated by the contract owner and is the only address authorized to trigger token transfers using the rescueERC20 function. This mechanism is intended to prevent loss of assets due to incorrect or stuck transfers.

The EIP2612V3  abstract contract provides an internal implementation of EIP-2612, enabling gas-abstracted token approvals via off-chain signatures. It uses typed structured data in accordance with EIP-712 and integrates nonce tracking to prevent replay attacks. Signature validity is verified at execution using a utility function, and upon successful verification, the allowance is updated through an internal approval method.

The EIP3009V3 abstract contract implements EIP-3009, enabling off-chain authorized transfers and cancellations through gas-abstracted mechanisms. Authorization data includes validity windows and unique nonces, which are checked to prevent replay and front-running attacks. Signature verification is performed using EIP-712 structured data hashing, and authorization state is tracked to ensure single-use enforcement.

This Proxy contract defines a proxy pattern enabling delegation of all calls to a designated implementation address determined at runtime. The fallback function captures all unmatched calls and forwards them via low-level delegatecall.

Privileged roles

The FiatTokenV3 contract uses the custom implementation of  Ownable contract and custom access control roles to restrict access to important functions.

• The contract owner can:

• • Updates the pauser address.

  • Update the masterMinter address.

  • Updates the rescuer address.

  • Updates the blacklister address.

  • Transfer control of the contract to a new owner.

• The address stored in masterMinter can:

• • Add or update minters with specific minting allowances.

  • Remove existing minters.

• The address marked as minter can:

• • Mint new tokens within their configured allowances.

  • Burn their own token balances.

• The address stored in blacklister can:

• • Blacklist and unblacklist accounts, preventing them from interacting with the token.

• The address stored in pauser can:

• • Pause and unpause contract operations.

• The address stored in rescuer can:

• • Rescue ERC20 tokens locked up in this contract.

The MintController contract extends the Controller contract that uses a custom implementation of  Ownable contract that restrict access to important functions.

• The contract owner can:

• • Set a new minterManager address via setMinterManager().

  • Assign a controller to a specific worker using configureController().

  • Remove a controller by setting its associated worker to the zero address via removeController().

• Addresses defined as controllers in the internal controllers mapping can:

• • Enable and set an allowance for their associated minter using configureMinter().

  • Remove their associated minter using removeMinter().

  • Increment the allowance for their associated minter using incrementMinterAllowance().

  • Decrement the allowance for their associated minter using decrementMinterAllowance().

The scope of the project includes the following smart contracts from the provided repository: