Lifty Gaming contract 0xa4b7…a529 on Ethereum

0xa4b71b99eef99ea217adb7e3641cb3e779eaa529

As of 21 Nov 2026, Trustblock’s record holds 0xa4b71b99eef99ea217adb7e3641cb3e779eaa529 on Ethereum as a contract of Lifty Gaming. 1 audit report on Trustblock lists this address: CertiK, 21 Apr 2023. 6 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
LiftyCertiKNot recorded (see the report)Open

Open and acknowledged findings in these reports6

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

HighCentralization Risks in FeeProvider.solLifty · CertiKOpen

In the contract `FeeProvider` the role `_owner` has authority over the functions shown in the diagram below: ![](https://accelerator-tasks-prod.acc.corp.certik.com/4702cd2235494e3c9657e181fcc387ad/diagrams/centralization_FeeProvider-FeeProvider-_owner.svg) - `changeFeesBeneficiary()`: Change the address of the beneficiary of the fees. - `changeMarketplaceCollectionFee()`: Change the marketplace fees for a collection given. - `changeCollectionRoyalties()`: Change the amounts and recipients of the royalties for a collection given Any compromise to the `_owner` account may allow the hacker to take advantage of this authority and change the amount fees collected for a an arbitrary collection.

The audit on Trustblock · Open the report
LowAsset Used To Calculate FeesLifty · CertiKAcknowledged

When fees are applied to a transfer, the fees used are determined by the first asset in the `assets` array, which is the first bid asset in a sale and the first ask asset in an offer. ```solidity=54 transferPaymentAndFees( from, to, payment[i], assets[0], assets.length == 1, amount ); ``` This allows the order maker to arrange the bid and ask arrays such that the first token in each array has the lowest fees, resulting in possibly fewer fees collected by the protocol.

The audit on Trustblock · Open the report
LowImplementation of Merkle TreeLifty · CertiKAcknowledged

When processing an order, there is a check requiring proof that the order's hash is compatible with the root of a Merkle tree. ```solidity=125 require( order.signer == recoverSigner(order.rootSign, order.root), "ProceedOrder: wrong root sign" ); // check order merkle tree proof require( MerkleTree.verify(order.proof, order.root, orderHash), "ProceedOrder: invalid proof" ); ``` The root of the Merkle tree is also checked to be signed by `order.signer`. Since `order.amount` is not included in an order's hash, this allows the same order, with the same `order.root` and the same `order.rootSign`, but with a different `order.amount` to be processed multiple times.

The audit on Trustblock · Open the report
LowLack of Checks on Royalty feesLifty · CertiKAcknowledged

In the function `changeMarketplaceCollectionFee()`, upper fee checks are implemented on the `marketplaceCollectionFee`. ```solidity=148 function changeMarketplaceCollectionFee( address collection, uint16 buyerFee, uint16 sellerFee ) external onlyOwner { require( sellerFee < 10000 && buyerFee < 10000, "FeeProvider: wrong fee amount" ); ``` --- However, for the *royalties* that are using `customCollectionRoyalties` the royalties are calculated using an external call `IGetRoyalties(collection)` without upper checks requirements. ```solidity=115 if (IERC165(collection).supportsInterface(INTERFACE_ID_FEES)) { IGetRoyalties collection = IGetRoyalties(collection); return (collection.getFeeRecipients(id), collection.getFeeBps(id)); } ```

The audit on Trustblock · Open the report
LowOrder Taker Decides Order TypeLifty · CertiKAcknowledged

The order type determines how fees are implemented, where the order maker pays fees for an `OFFER` and the order taker pays fees for a `SALE`. In the case of a `SWAP`, no fees are applied. Since the order type is not part of an order's hash, this allows the order taker to always state the order's type is a `SWAP` to avoid fees.

The audit on Trustblock · Open the report
LowPayable Buy FunctionLifty · CertiKAcknowledged

The function `buy()` is used to fill orders involving `ERC20`, `ERC721`, `ERC1155`, and native tokens. ```solidity=67 function buy( Order[] calldata orders, uint expiredAt, bytes calldata dealSign, bytes32[] calldata ordersHashes ) external payable nonReentrant { require(expiredAt > block.timestamp, "Buy: the deal is expired."); require( verifyDealSign(expiredAt, dealSign, ordersHashes), "Buy: wrong deal signature" ); for (uint256 i = 0; i < orders.length; ) { proceedOrder(orders[i], ordersHashes[i]); unchecked { ++i; } } } ``` Since there is no check that `msg.value` is the correct amount in the case of native token transfers, it is possible for native tokens to forever be locked within the contract.

The audit on Trustblock · Open the report

The Lifty Gaming security record · Every Lifty Gaming address · This address on the explorer