Ordinal Doge contract 0x7b0f…3dca on Ethereum

0x7b0fce54574d9746414d11367f54c9ab94e53dca

As of 21 Nov 2026, Trustblock’s record holds 0x7b0fce54574d9746414d11367f54c9ab94e53dca on Ethereum as a contract of Ordinal Doge. 1 audit report on Trustblock lists this address: CertiK, 20 Apr 2023. 11 findings in it are recorded as open or acknowledged.

Audit reports that list this address1

Each report’s scope as stored on Trustblock names this address on Ethereum.

AuditSecurity firmDateCommit named in the reportReport
$oDOGECertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports11

1 High, 3 Medium, 7 Low. In the firm’s own words; statuses are the firm’s, from each report.

HighState Variable Initialization In Constructor With$oDOGE · CertiKAcknowledged

Code inside the constructor is only executed during the deployment of the contract and only affects the state of the implementation contract. Therefore, it will never be executed in the context of the proxy’s state which makes it irrelevant for an upgradeable contract.

The audit on Trustblock · Open the report
Medium`ERC721` Not Explicitly Transferred In Before Auc$oDOGE · CertiKAcknowledged

Although the contract `TokenVault` implements the contract `ERC721HolderUpgradeable` to receive the ERC-721 tokens for auction, it does not explicitly calls the function `IERC721(token).transferFrom` to transfer the ERC-721 tokens to the current contract address. Thus, the winners may not able to get the auction token in the function `end()`. The function `initialize()` only set the token address and id, but does not transfer the token ownership to the contract address. Since the function `initialize()` can be called by anyone, anyone can create the auction and become the `curator` even if he/she is not the token owner.

The audit on Trustblock · Open the report
MediumFallback Function May Suffer Out-Of-Gas Error$oDOGE · CertiKAcknowledged

In the Ethereum, `send/transfer/call` can be used for ETH transferrings. In the worst case, the fallback function can only rely on 2300 gas being available (for example when `send` or `transfer` is used), leaving little room to perform other operations except basic logging. Therefore, the fallback function of the current contract is not suitable for doing much. The contract `InitializedProxy` will make a delegate call to the `_impl` contract, which may cause the out-of-gas error. ```solidity fallback() external payable { address _impl = logic; assembly { let ptr := mload(0x40) calldatacopy(ptr, 0, calldatasize()) let result := delegatecall(gas(), _impl, ptr, calldatasize(), 0, 0) let size := returndatasize() returndatacopy(ptr, 0, size) switch result case 0 { revert(ptr, size) } default { return(ptr, size) } } } ```

The audit on Trustblock · Open the report
MediumIneffective `isContract()` Check$oDOGE · CertiKAcknowledged

The implementation of the `isContract` check can not cover all scenarios. The check can be bypassed if the call is from the constructor of a smart contract or when the contract is destroyed. In that case, the codesize will also be zero. The "isContract" function in the OpenZeppelin "Address" library uses the same implementation, but comments mention that "it's unsafe to rely on the check and it can be bypassed". Reference: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol.

The audit on Trustblock · Open the report
LowDivide Before Multiply$oDOGE · CertiKAcknowledged

Performing integer division before multiplication truncates the low bits, losing the precision of calculation. ```solidity=210 uint256 feePerSecond = currentAnnualFee / 31536000; ``` ```solidity=214 uint256 curatorMint = sinceLastClaim * feePerSecond; ``` --- ```solidity=220 feePerSecond = currentAnnualFee / 31536000; ``` ```solidity=221 uint256 govMint = sinceLastClaim * feePerSecond; ``` --- ```solidity=251 uint256 averageReserve = reserveTotal / votingTokens; ``` ```solidity=253 uint256 reservePriceMin = averageReserve * ISettings(settings).minReserveFactor() / 1000; ``` --- ```solidity=268 uint256 averageReserve = (reserveTotal - (old * weight)) / (votingTokens - weight); ``` ```solidity=270 uint256 reservePriceMin = averageReserve * ISettings(settings).minReserveFactor() / 1000; ```

The audit on Trustblock · Open the report
LowLack of reasonable boundary$oDOGE · CertiKAcknowledged

The function `initialize()` does not contain the necessary boundary checks for `fee`. Also, the variable `maxCuratorFee` does not have a reasonable boundary.

The audit on Trustblock · Open the report
LowLogic Issue On Auction Price Setting$oDOGE · CertiKAcknowledged

The contract `TokenVault` is an ERC20 token. The holders of this token can propose the auction price of a certain ERC721 token, with the holding balance as the voting weight. The final auction start price will be the average of the proposed prices. The one who calls the function `initialize()` will mint the initial tokens to the `curator` and set the initial price for the `curator`. The token can be transferred and the voted price will be changed because of the balance changes. If the auction is successfully ended, all the holders can get the ETH from the auction in proportion to the user balance. If the `curator` does not perform any transfer, only the `curator` and the `govAddress` will get the price voting power by claiming fees. However, the newly minted tokens do not automatically contribute to the price voting. In the code snippet below, the `if` condition `_from != address(0)` will skip the voting price update for mint. ```solidity=287 function _beforeTokenTransfer(address _from, address _to, uint256 _amount) internal virtual override { if (_from != address(0) && auctionState == State.inactive) { ... //CetiK comment: update the voting price based on new balances ```

The audit on Trustblock · Open the report
LowMissing Zero Address Validation$oDOGE · CertiKAcknowledged

Addresses should be checked before assignment or external call to make sure they are not zero addresses. ```solidity=106 settings = _settings; ``` - `_settings` is not zero-checked before being used. --- ```solidity=114 token = _token; ``` - `_token` is not zero-checked before being used. --- ```solidity=118 curator = _curator; ``` - `_curator` is not zero-checked before being used. --- ```solidity=146 curator = _curator; ``` - `_curator` is not zero-checked before being used. --- ```solidity=175 curator = _curator; ``` - `_curator` is not zero-checked before being used.

The audit on Trustblock · Open the report
LowOpenZeppelin Library Code Included in Source Code$oDOGE · CertiKAcknowledged

It is highly recommended NOT to include OpenZeppelin library code directly in source code, but import the original library to minimize risk because even slight changes to the library code may lead to critical/major vulnerabilities/bugs. For Solidity version 0.6.x, the latest OpenZeppelin version 3.4.2 should be used.

The audit on Trustblock · Open the report
LowPotential Front-Running Risk$oDOGE · CertiKAcknowledged

Since there is no access restriction on the function `initialize()`, malicious hackers can execute the function `initialize()` to get the `curator` role, get new ERC20 tokens minted, and set a new auction price.

The audit on Trustblock · Open the report
LowUnused Variable$oDOGE · CertiKAcknowledged

The variable `vaultClosed` is declared but not used. ```solidity=75 bool public vaultClosed; ```

The audit on Trustblock · Open the report

The Ordinal Doge security record · Every Ordinal Doge address · This address on the explorer