0x03dde9e5bb31ee40a471476e2fccf75c67921062
As of 21 Nov 2026, Trustblock’s record holds 0x03dde9e5bb31ee40a471476e2fccf75c67921062 on Ethereum as a contract of EML. 1 audit report on Trustblock lists this address: CertiK, 13 Jun 2023. 12 findings in it are recorded as open or acknowledged.
Each report’s scope as stored on Trustblock names this address on Ethereum.
2 High, 1 Medium, 9 Low. In the firm’s own words; statuses are the firm’s, from each report.
### Token_Factory.sol #### _owner In the contract `TokenFactory` the role `_owner` has authority over the functions shown in the diagram and list below. * createProxy() - Create new token proxy contract Any compromise to the `_owner` account may allow the hacker to take advantage of this authority to create new proxy token contracts.  ### Token_Implementation.sol #### _burners In the contract `TokenImplementation` the role `_burners` has authority over the functions shown in the diagram and list below. * burn() - Burn tokens Any compromise to the `_burners` account may allow the hacker to take advantage of this authority to burn tokens.  #### _lockers In the contract `TokenImplementation` the role `_lockers` has authority over the functions shown in the diagram and list below. * updateVestingLock() - Update an existing vesting lock for an account * vestedTransfer() - Create a transfer and then create a vesting lock over those tokens * batchVestedTransfer() - Create a multiple transfers and then create a vesting lock over each of those transfer amounts * batchTimeLockedTransfer() - Create a multiple transfers and then create a time lock over each of those transfer amounts * lockedTransfer() - Create a transfer and then create a time lock over those tokens * addTimeLock() - Create a new time lock on account tokens * addVestingLock() - Create a new vesting lock on account tokens Any compromise to the `_lockers` account may allow the hacker to take advantage of this authority to control the locking of tokens.  #### _owner In the contract `TokenImplementation` the role `_owner` has authority over the functions shown in the diagram and list below. * unpause() - Unpause contract to reactivate certain functions * addLocker() - Add locker role * removeLocker() - Remove locker role * recoverToken() - Send tokens from contract to owner * pause() - Pause contract to disable certain functions * removeBurner() - Remove burner role * freeze() - Freeze account to disable account functionality * addBurner() - Add burner role The following are functions that the `_owner` role can run since `TokenImplementation` extends `OwnableUpgradeable`. * transferOwnership() - Transfer contract ownership to another address * renounceOwnership() - Give up contract ownership Any compromise to the `_owner` account may allow the hacker to take advantage of this authority to control/restrict contract and account functionality and add privileged authorizations.   #### _supervisor In the contract `TokenImplementation` the role `_supervisor` has authority over the functions shown in the diagram and list below. * unfreeze() - Unfreeze account to reenable account functionality * transferSupervisorOwnership() - Transfer supervisor role * renounceSupervisorOwnership() - Give up supervisor role * removeVestingLock() - Remove a vesting lock for an account * removeTimeLock() - Remove time lock for certain amount of account’s tokens Any compromise to the `_supervisor` account may allow the hacker to take advantage of this authority to restore account functionality and remove token locks. 
The audit on Trustblock · Open the reportAll EML tokens are sent to the contract owner when deploying the contract. This is a potential centralization risk as the owner can distribute EML tokens without the consensus of the community. The token is already deployed on the Ethereum mainnet and the following link shows the top token holder balances: [https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062#balances](https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062#balances). The addresses are as follows: 1. 0x0cBeB1c3cAc0BD1EFaCAe164342cb535bdAe931c 2. 0x2DbE49882Fa742A5DEc0fd5b7842643636BE4118 3. 0x219C8A930879575F739206e899468beDe4b56baD 4. 0xba038dB66D4F5AcB9328518CE16519c19910c696 5. 0xdc30E4862AfE00eB835d5d06dc1955bc799e34d5 6. 0xCB82131FeadE6dddD7BA4744Ff8Fe8c8c8012252 7. 0x321C3cCede20F02a7f9d9e34CAd6834b07D4217d The following transactions show that the top token holders were all transferred tokens from the token owner contract: 1. [https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062?a=0x9bda9e70fdbf0d9cbab1db1d3ecafcfe084b412f](https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062?a=0x9bda9e70fdbf0d9cbab1db1d3ecafcfe084b412f) 2. [https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062?a=0x321c3ccede20f02a7f9d9e34cad6834b07d4217d](https://etherscan.io/token/0x03dde9e5bb31ee40a471476e2fccf75c67921062?a=0x321c3ccede20f02a7f9d9e34cad6834b07d4217d)
The audit on Trustblock · Open the reportChecks should be made to ensure that the vesting and time lock amounts are not greater than the leftover unlocked balance. Lack of these checks can lead to locked balances greater than the overall balance of the user and cause all transactions for that user to revert. In function `Lockable._updateVestingLock()` there is only a check to ensure that the input amount is greater than 0, however this is not enough to prevent issues from occurring since there is no upper limit to the amount that can be input in the `amount` parameter. ```solidity=326 require(amount > 0, "VestingLock: amount is 0"); ``` In function `Lockable._addTimeLock()` there is only a check to ensure that the input amount is greater than 0, however this is not enough to prevent issues from occurring since there is no upper limit to the amount that can be input in the `amount` parameter. ```solidity=222 require(amount > 0, "TimeLock: lock amount is 0"); ``` In function `TokenImplementation.addVestingLock()` there is a check to ensure that the value of `amount` is both greater than 0 and is under the total token balance of the account. ```solidity=551 require(amount > 0 && balanceOf(account) >= amount, "VestingLock: amount is 0 or over balance"); ``` For all transfers, the `_beforeTokenTransfer()` will be run to run a series of checks before the transfers occur. If the total locked amount (`getAllLockedAmount(from)`) is greater than the `balanceOf(from)`, all transfers for the user will fail even if the user has unlocked tokens. ```solidity=440 if (from != address(0)) require(balanceOf(from) - getAllLockedAmount(from) >= amount, "Lockable: insufficient transfer amount"); ```
The audit on Trustblock · Open the reportThe current setup of the `TokenFactory` contract grants the ability to create numerous different clones of tokens based on the same implementation contract. After review of the whitepaper and other documentation, it seems that the only token in the ecosystem is the EML token in which the maximum supply has already been minted. The minting of new "EML token" contracts might have unintended consequences and might cause confusion within the community. The audit team would like to better understand the current implementation and whether there are plans for other tokens in the future.
The audit on Trustblock · Open the reportOne or more parameters with `memory` data location are never modified in their functions and those functions are never called internally within the contract. Thus, their data location can be changed to `calldata` to avoid the gas consumption copying from calldata to memory. ```solidity=17 function createProxy(address owner, string memory name, string memory symbol, uint256 initialSupply) public onlyOwner returns (address) { ``` `createProxy` has memory location parameters: `name`, `symbol`. --- ```solidity=408 function initialize(address owner, string memory name, string memory symbol, uint256 initialSupply) public initializer { ``` `initialize` has memory location parameters: `name`, `symbol`. --- ```solidity=573 function batchTransfer(address[] memory recipients, uint256[] memory amounts) public { ``` `batchTransfer` has memory location parameters: `recipients`, `amounts`. --- ```solidity=607 function batchVestedTransfer( ``` `batchVestedTransfer` has memory location parameters: `recipients`, `amounts`, `startsAt`, `periods`, `counts`. --- ```solidity=648 function batchTimeLockedTransfer( ``` `batchTimeLockedTransfer` has memory location parameters: `recipients`, `amounts`, `expiresAt`.
The audit on Trustblock · Open the reportIn the EML token implementation, there is a potential missing check on the user's balance when adding a timelock in the `addTimeLock` function. Here is the existing `addTimeLock` function: ```solidity /** * @dev only locker can add time lock */ function addTimeLock( address account, uint256 amount, uint256 expiresAt ) public onlyLocker whenNotPaused { _addTimeLock(account, amount, expiresAt); } ``` There is no verification that `amount` is less than or equal to the balance of `account`. This could lead to potential issues if the function is called with an `amount` that is larger than `account`'s balance. For comparison, the `addVestingLock` function has a proper check on the `amount` and the balance of the `account`: ```solidity /** * @dev only locker can add vesting lock */ function addVestingLock( address account, uint256 amount, uint256 startsAt, uint256 period, uint256 count ) public onlyLocker whenNotPaused { require(amount > 0 && balanceOf(account) >= amount, "VestingLock: amount is 0 or over balance"); _addVestingLock(account, amount, startsAt, period, count); } ```
The audit on Trustblock · Open the reportAddresses are not validated before assignment or external calls, potentially allowing the use of zero addresses and leading to unexpected behavior or vulnerabilities. For example, transferring tokens to a zero address can result in a permanent loss of those tokens. ```solidity=14 logicContract = _logicContract; ``` - `_logicContract` is not zero-checked before being used.
The audit on Trustblock · Open the reportThe locker role is able to add and update locks for an account through the following functions: - `addTimeLock()` - `addVestingLock()` - `updateVestingLock()` The concern is that users can front-run those functions by transferring the EML tokens before the lock is imposed, thus bypassing the lock period.
The audit on Trustblock · Open the reportSince the locker contracts are in charge of creating token locks and sending funds to various wallets, the audit team would like to better understand the management of funds and how the team expects to ensure that there are sufficient funds within each locker wallet to operate and continue the distribution of funds to users.
The audit on Trustblock · Open the reportThe return values of the `transfer()` and `transferFrom()` calls in the smart contract are not checked. Some ERC-20 tokens' transfer functions return no values, while others return a bool value, they should be handled with care. If a function returns `false` instead of reverting upon failure, an unchecked failed transfer could be mistakenly considered successful in the contract. ```solidity=425 IERC20Upgradeable(tokenAddress).transfer(owner(), tokenAmount); ```
The audit on Trustblock · Open the reportOne or more logic contracts do not protect their initializers. An attacker can call the initializer and assume ownership of the logic contract, whereby he/she can perform privileged operations that trick unsuspecting users into believing that she is the owner of the upgradeable contract. ```solidity=406 contract TokenImplementation is Initializable, PausableUpgradeable, OwnableUpgradeable, Supervisable, Burnable, Freezable, Lockable, ERC20Upgradeable { ``` - `TokenImplementation` is an upgradeable contract that does not protect its initializer. ```solidity=408 function initialize(address owner, string memory name, string memory symbol, uint256 initialSupply) public initializer { ``` - `initialize` is an unprotected initializer function.
The audit on Trustblock · Open the reportThe linked variables assigned in the constructor can be declared as `immutable`. Immutable state variables can be assigned during contract creation but will remain constant throughout the lifetime of a deployed contract. A big advantage of immutable variables is that reading them is significantly cheaper than reading from regular state variables since they will not be stored in storage.
The audit on Trustblock · Open the reportThe EML security record · Every EML address · This address on the explorer