As of 3 Nov 2026, Sat.is has 1 audit report on Trustblock, by CertiK, dated 31 Mar 2023. That report lists no open critical findings.
Record last updated . It holds audits, findings and contracts up to Nov 2026, and incidents up to Oct 2026. Trustblock does not review code.
Newest first
| Audit | Security firm | Date | Scope | Critical findings | Report |
|---|---|---|---|---|---|
| Sat.is - Audit | Security firm: CertiK | Date: | Scope: Files named in the report | No open critical findings | Open · skynet.certik.com |
Statuses are the security firm’s own, from each report.
| Severity | Open | Acknowledged | Fixed |
|---|---|---|---|
| Critical | 0 | 0 | 0 |
| High | 0 | 0 | 1 |
| Medium | 0 | 1 | 3 |
| Low | 1 | 0 | 13 |
**(compile_error)** A compile error was detected. * Build target: contracts/v2/sigma_mining ```solidity TypeError: Member "getSatisTokenAmountInContract" not found or not visible after argument-dependent lookup in contract IMoneyPoolRaw. --> project:/sigma_mining/SigmaPoolProxy.sol:99:28: | 99 | satisTokenInPool = sigmaPoolContract.getSatisTokenAmountInContract(_tokenAddress); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` --- **(compile_error)** A compile error was detected. * Build target: contracts/v2/sigma_mining/SigmaPoolProxy.sol ```solidity crytic_compile.platform.exceptions.InvalidCompilation: TypeError: TypeError: Member "getSatisTokenAmountInContract" not found or not visible after argument-dependent lookup in contract IMoneyPoolRaw. --> ./contracts/v2/sigma_mining/SigmaPoolProxy.sol:99:28: | 99 | satisTokenInPool = sigmaPoolContract.getSatisTokenAmountInContract(_tokenAddress); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- TypeError: TypeError: Member "getSatisTokenAmountInContract" not found or not visible after argument-dependent lookup in contract IMoneyPoolRaw. --> ./contracts/v2/sigma_mining/SigmaPoolProxy.sol:99:28: | 99 | satisTokenInPool = sigmaPoolContract.getSatisTokenAmountInContract(_tokenAddress); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -- TypeError: TypeError: Member "getSatisTokenAmountInContract" not found or not visible after argument-dependent lookup in contract IMoneyPoolRaw. --> ./contracts/v2/sigma_mining/SigmaPoolProxy.sol:99:28: | 99 | satisTokenInPool = sigmaPoolContract.getSatisTokenAmountInContract(_tokenAddress); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ``` --- **(compile_error)** A compile error was detected. * Build target: contracts/v2/lib_and_interface ```solidity ParserError: Expected '{' but got '}' --> project:/lib_and_interface/ISigmaPoolRaw.sol:69:1: | 69 | } | ^ ``` --- **(compile_error)** A compile error was detected. * Build target: contracts/v2/lib_and_interface/ISigmaPoolRaw.sol ```solidity crytic_compile.platform.exceptions.InvalidCompilation: ParserError: ParserError: Expected '{' but got '}' --> ./contracts/v2/lib_and_interface/ISigmaPoolRaw.sol:69:1: | 69 | } | ^ -- ParserError: ParserError: Expected '{' but got '}' --> ./contracts/v2/lib_and_interface/ISigmaPoolRaw.sol:69:1: | 69 | } | ^ -- ParserError: ParserError: Expected '{' but got '}' --> ./contracts/v2/lib_and_interface/ISigmaPoolRaw.sol:69:1: | 69 | } | ^ ```
Open the reportThe design and implementation of the "sigmaVerifyAndUnlockFund" function are problematic and confusing for the following reasons: 1. Why does the function need the "_newLockValue" argument? Shouldn't the new locked value be `oldLock - _unlockValue`? 2. The user can call the function `sigmaVerifyAndUnlockFund()` to unlock funds. On lines 248 and 254, if the new lock value is greater than the old lock value, the difference between the two values is added to the clientSigmaBalance. Conversely, if the new lock value is less than the old lock value, the difference is subtracted from the clientSigmaBalance. However, `clientSigmaBalance` represents the balance of the user, not the lock balance. Why is the `clientSigmaBalance` being updated here without funds being transferred in or out? 3. If the _newLockValue is less than the _unlockValue, line 257 will cause the function to revert due to underflow. There should be a check to ensure that this does not happen.
Open the reportEncoding through `abi.encodePacked()` is used with at least two dynamic type inputs controlled by the user. This type of encoding is susceptible to malleability when used with strings, bytes, or other dynamic types. As such, it is not a good choice for signature verification with the input used, since users can change the input and potentially get the same bytes output from `abi.encodePacked`. Moreover, note that uints and other variable types do not need to be converted to strings before being encoded.
Open the reportThe worker can unlock funds to instant withdrawal reserve by calling the `workerUnlockFund()` function. At line 318, `unlockToken` tokens are transferred to the `_clientAddressList` and the value is added to the `instantWithdrawReserve`. If the worker dumps funds for instant withdrawal to the same `_clientAddressList` by calling the `workerDumpInstantWithdrawalFund()` function, the `_clientAddressList` will receive the same value of `dumpToken` tokens. ```solidity=317 for (uint i = 0; i < _clientAddressList.length; i++) { unlockToken.safeTransfer(_clientAddressList[i], _tokenValueList[i]); instantWithdrawReserve[_clientAddressList[i]][_tokenAddress] = instantWithdrawReserve[_clientAddressList[i]] [_tokenAddress].add(_tokenValueList[i]); } ```
Open the reportThe `verifyAndWithdrawFund()` and `verifyAndPartialWithdrawFund()` functions in the `MoneyPoolProxy` contract both implement the same logic, which withdraws funds and emits events. The only difference is that the input parameter for the withdrawn value defines different variables. Similarly, the `sigmaVerifyAndWithdrawFund()` and `sigmaVerifyAndPartialWithdrawFund()` functions also have the same issue.
Open the reportThe `fundSatisToken()` function of the `MoneyPoolRaw` contract is only caller by the worker, but the `sigmaFundSatisToken()` function can be called by anyone as it has no access restriction. This enables anyone to call this and transfer `satisToken` tokens to the contract.
Open the reportThere should always be events emitted in the sensitive functions that are controlled by centralization roles.
Open the reportThe **require** can be used to check for conditions and throw an exception if the condition is not met. It is better to provide a string message containing details about the error that will be passed back to the caller.
Open the reportAddresses should be checked before assignment or external call to make sure they are not zero addresses. ```solidity=34 proxy = _initialProxyAddress; ``` - `_initialProxyAddress` is not zero-checked before being used. --- ```solidity=41 owner = _newOwner; ``` - `_newOwner` is not zero-checked before being used. --- ```solidity=48 proxy = _newProxyAddress; ``` - `_newProxyAddress` is not zero-checked before being used. --- ```solidity=55 actionContractAddress = _actionContractAddress; ``` - `_actionContractAddress` is not zero-checked before being used. --- ```solidity=112 owner = _newOwner; ``` - `_newOwner` is not zero-checked before being used. --- ```solidity=149 actionContractAddress = _newActionContractAddress; ``` - `_newActionContractAddress` is not zero-checked before being used. --- ```solidity=96 proxy = _initialProxyAddress; ``` - `_initialProxyAddress` is not zero-checked before being used. --- ```solidity=97 sigmaProxy = _initialSigmaProxyAddress; ``` - `_initialSigmaProxyAddress` is not zero-checked before being used. --- ```solidity=161 owner = _newOwner; ``` - `_newOwner` is not zero-checked before being used. --- ```solidity=186 proxy = _newProxyAddress; ``` - `_newProxyAddress` is not zero-checked before being used. --- ```solidity=193 sigmaProxy = _newSigmaProxyAddress; ``` - `_newSigmaProxyAddress` is not zero-checked before being used. --- ```solidity=33 proxy = _initialProxyAddress; ``` - `_initialProxyAddress` is not zero-checked before being used. --- ```solidity=40 owner = _newOwner; ``` - `_newOwner` is not zero-checked before being used. --- ```solidity=47 proxy = _newProxyAddress; ``` - `_newProxyAddress` is not zero-checked before being used. --- ```solidity=59 sigmaProxy = _initialProxyAddress; ``` - `_initialProxyAddress` is not zero-checked before being used. --- ```solidity=79 sigmaOwner = _newOwner; ``` - `_newOwner` is not zero-checked before being used. --- ```solidity=95 sigmaProxy = _newProxyAddress; ``` - `_newProxyAddress` is not zero-checked before being used.
Open the reportThe interface in the "ISigmaPoolRaw.sol" file is named "IMoneyPoolRaw," and the pool object created in "SigmaPoolProxy.sol" is also named "IMoneyPoolRaw." However, based on the context, it appears that "SigmaPool" and "MoneyPool" are two different pools. For example: The `IMoneyPoolRaw` usage ```sol=69 function getClientSigmaNonce(address _clientAddress, string memory _poolName) external view returns(uint256 clientSigmaNonce) { require(sigmaPoolAddressList[_poolName] != address(0), "No such pool"); IMoneyPoolRaw sigmaPoolContract = IMoneyPoolRaw(sigmaPoolAddressList[_poolName]); clientSigmaNonce = sigmaPoolContract.getClientNonce(_clientAddress); } ``` Also, the "SigmaPoolRaw.sol" contract doesn't have the "addFundWithAction" function. ```sol=169 function sigmaAddFundWithAction(address _tokenAddress, uint256 _tokenValue, string memory _data, string memory _poolName) external returns(bool _isDone) { require(sigmaPoolAddressList[_poolName] != address(0), "No such pool"); IMoneyPoolRaw sigmaPoolContract = IMoneyPoolRaw(sigmaPoolAddressList[_poolName]); bool _addDone = sigmaPoolContract.addFundWithAction(msg.sender, _tokenAddress, _tokenValue, int(_tokenValue)); ISigmaAction sigmaActionContract = ISigmaAction(sigmaActionContractAddress); bool _eventDone = sigmaActionContract.sigmaAddFundWithAction(msg.sender, _tokenAddress, _tokenValue, _data); _isDone = _addDone && _eventDone; } ```
Open the reportIn the `constructor`, the owner is added to the `workerList`. However, in the `transferOwnershipMoneyPoolProxy()` function, although the ownership is transferred to the new owner, they are not added to the `workerList`. The following functions have the same issue: - `transferOwnership()` in `MoneyPoolRaw()` contract - `transferOwnershipSigmaPoolProxy()` in `SigmalPoolProxy()` contract - `transferSigmaOwnership()` in `SigmalPoolRaw()` contract
Open the reportThe `sigmaAddFund()`, `sigmaLockFundWithAction`, `sigmaAddFundWithAction`, `sigmaRemoveFund()`, `sigmaVerifyAndUnlockFund()`, `sigmaVerifyAndRemoveFund()` and `sigmaVerifyAndRedeemToken` functions require that the caller is `sigmaProxy`, but there is currently no function that calls them in the `SigmaPoolProxy` contract.
Open the reportWithin the current contract, there is no distinction between the different blockchains supported by `MoneypoolRaw`/`SigmaPoolRaw`. If the signer signed a message on one chain (e.g. Ethereum), and accidentally leaks the message, the message would be valid for a similar transaction of a chain with the same encryption method (e.g. BSC). For example, if the signer signed a message (_targetSignature, _clientAddress, _tokenAddress, _withdrawValue, _tier, _nonce) on Ethereum and the same _clientAddress, _tokenAddress exists on BSC. The attacker can reuse this signed message to withdraw funds on BSC.
Open the reportThe linked codes are redundant because the modifier `correctSignatureLength` has already checked the signature length.
Open the reportThe linked statements do not affect the functionality of the codebase and appear to be either leftovers from test code or older functionality.
Open the reportThe `SafeMath` library is used unnecessarily. With Solidity compiler versions 0.8.0 or newer, arithmetic operations will automatically revert in case of integer overflow or underflow. ```solidity=204 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=486 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `SafeERC20` contract. ```solidity=516 uint256 newAllowance = token.allowance(address(this), spender).add(value); ``` - `SafeMath.add` is called in `safeIncreaseAllowance` function of `SafeERC20` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 3) are shown above.* --- ```solidity=560 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `MoneyPoolRaw` contract. ```solidity=635 clientBalance[msg.sender][_tokenAddress] = clientBalance[msg.sender][_tokenAddress].add(_tokenValue); ``` - `SafeMath.add` is called in `addFund` function of `MoneyPoolRaw` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 13) are shown above.* --- ```solidity=486 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `SafeERC20` contract. ```solidity=516 uint256 newAllowance = token.allowance(address(this), spender).add(value); ``` - `SafeMath.add` is called in `safeIncreaseAllowance` function of `SafeERC20` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 3) are shown above.* --- ```solidity=19 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `SafeERC20` contract. ```solidity=49 uint256 newAllowance = token.allowance(address(this), spender).add(value); ``` - `SafeMath.add` is called in `safeIncreaseAllowance` function of `SafeERC20` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 3) are shown above.* --- ```solidity=18 library SafeMath { ``` - An implementation of `SafeMath` library is found. --- ```solidity=24 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `MoneyPoolRaw` contract. ```solidity=218 totalLockedAssets[_tokenAddress] = totalLockedAssets[_tokenAddress].add(_addValue); ``` - `SafeMath.add` is called in `addFundWithAction` function of `MoneyPoolRaw` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 18) are shown above.* --- ```solidity=13 using SafeMath for uint256; ``` - `SafeMath` library is used for `uint256` type in `SigmaPoolRaw` contract. ```solidity=109 clientSigmaBalance[_clientAddress][_tokenAddress] = clientSigmaBalance[_clientAddress][_tokenAddress].add(_tokenValue); ``` - `SafeMath.add` is called in `sigmaAddFund` function of `SigmaPoolRaw` contract. *Note: Only a sample of 2 `SafeMath` library usage in this contract (out of 17) are shown above.*
Open the reportThe `_data` function argument is not used in the "sigmaLockFundWithAction" function. ```113 function sigmaLockFundWithAction(address _clientAddress, address _tokenAddress, uint256 _tokenValue, string memory _data) public isProxy enoughMobileBalance(_clientAddress, _tokenAddress, _tokenValue) returns(bool _isDone) { clientSigmaLockBalance[_clientAddress][_tokenAddress] = clientSigmaLockBalance[_clientAddress][_tokenAddress].add(_tokenValue); _isDone = true; } ```
Open the reportThe reports name a repository or files. Open a report to see its scope.
Is this your project? Show this record on your own website. The label states what the record holds, links to this page and updates by itself. It is free and needs no sign-in.
Automatic: the three strongest facts of this project’s own record (its last audit and two more), highlighted. They update with the record. Picking a fact turns Automatic off.
<head><script src="https://widget.trustblock.run/project-widget.min.js" defer></script></head><body><divdata-tb-project-widgetdata-tb-project-slug="satis"></div></body>
Paste the code where the label should appear. It uses no API credit and updates by itself.
Something wrong on this page? A missing report, a wrong date, a finding that was fixed since. Tell us and we check it against its source.
Tell us