NextGen — disclosed vulnerability reports and payouts
Every publicly disclosed and closed bug bounty report we hold for NextGen, with our own summary of each finding and a link to the original disclosure.
- Reports indexed
- 17
- Total paid
- $0
- Critical
- 0
- Largest payout
- $0
This page collects the 17 closed, publicly disclosed NextGen reports indexed on Coin Buggie. Nothing here is active or unpatched — every entry was published by the programme or the researcher after remediation.
The findings concentrate in Logic error, Reentrancy, Integer overflow / underflow, Oracle manipulation, Access control, across EVM-Solidity, Move. Reading a single protocol end to end is the fastest way to see which assumptions its codebase repeatedly gets wrong, which is usually a better predictor of where the next finding lives than the category alone.
Use the vulnerability class links below to compare these findings against the same bug class in other protocols.
What reviewers look for
- Logic error findings disclosed against NextGen
- Reentrancy findings disclosed against NextGen
- Integer overflow / underflow findings disclosed against NextGen
- Oracle manipulation findings disclosed against NextGen
- Access control findings disclosed against NextGen
Curated highlights
The largest disclosed payouts in this group, with our own summary of each. Every report links back to the original disclosure.
NextGen: Bidder Funds Can Become Unrecoverable Due to 1 second Overlap in `participateToAuction()` and `claimAuction()`
The NextGen protocol contains a critical logic error in its auction participation function, allowing bids to be submitted at the exact moment an auction concludes. This creates a race condition where a late bid can be accepted after the auction winner has already finalized the auction via `claimAuction()`. Because the claim process does not account for these late-arriving bids, the bidder's funds become permanently locked in the contract with no mechanism for recovery.
NextGen: If an airdrop happens before a mint the price could skyrocket
The NextGen protocol features a dynamic pricing mechanism for NFT mints that fails to differentiate between tokens minted via sales and those distributed via airdrops. Consequently, if a collection undergoes an airdrop, the total circulating supply increases, causing the `getPrice` function to calculate an inflated cost for subsequent sale-based mints. This results in unintended financial burdens on participants and undermines the protocol's planned pricing strategy for whitelisted users.
NextGen: Vulnerability in `burnToMint` function allows double use of NFT
The NextGen burnToMint function contains a critical ordering vulnerability that allows users to double-spend NFTs. Because the function mints a new token before burning the old one, it triggers an external _safeMint call while the original token is still active. An attacker can exploit this reentrancy window to transfer or sell the original NFT to a third party before the burn completes, resulting in the user receiving the new NFT while simultaneously profiting from the sale of the burned token.
NextGen: Auction payout goes to `AuctionDemo` contract owner, not the token owner
The NextGen auction contract contains a logic error where auction proceeds are incorrectly sent to the contract owner instead of the NFT seller. When an auction concludes and the winner claims the token, the smart contract routes the winning bid funds to the protocol owner's address. This violates the protocol's core invariant, causing a total loss of funds for the users attempting to sell their NFTs through the auction mechanism.
NextGen: Auction winner can prevent payments via `safeTransferFrom` callback
The auction finalization process in the NextGen protocol is susceptible to a denial-of-service attack. A malicious auction winner can provide a contract address as the recipient of the NFT, which triggers a callback during the safeTransferFrom process. By forcing this callback to revert, the attacker prevents the contract from completing the distribution of funds, effectively locking the winning bid payment and all other participants' refunds inside the contract. This behavior violates the protocol's core invariant that all participants must be refunded and the owner paid, potentially leading to permanent loss of funds or enabling a ransom-style attack.
NextGen: Permanent DoS due to non-shrinking array usage in an unbounded loop
The NextGen protocol utilizes unbounded arrays to store auction bid histories in its `AuctionDemo.sol` contract. These arrays grow monotonically as participants place bids and are never pruned. Consequently, several critical administrative and informational functions are forced to iterate through the entire history of bids, creating a vulnerability where an attacker can inflate the array size through small, repetitive bids until the computational cost of iteration exceeds the block gas limit, causing permanent denial of service for the auction.
All reports in this group
- NextGen: Unchecked return value of low-level `call()/delegatecall()`Logic error$0
- NextGen: On a Linear or Exponential Descending Sale Model, a user that mints on the last `block.timestamp` mints at an unexpected price.Logic error$0
- NextGen: Adversary can block `claimAuction()` due to push-strategy to transfer assets to multiple biddersLogic error$0
- NextGen: Multiple mints can brick any form of `salesOption` 3 mintingsInteger overflow/underflow$0
- NextGen: Attacker can reenter to mint all the collection supplyReentrancy$0
- NextGen: Attacker can drain all ETH from `AuctionDemo` when `block.timestamp == auctionEndTime`Reentrancy$0
- NextGen: `getPrice` `salesOption` 2 can round down to the lower barrier, skipping the last time periodInteger overflow/underflow$0
- NextGen: The `RandomizerVRF` and `RandomizerRNG` do not produce hash value.Oracle manipulation$0
- NextGen: User funds sent in excess are not refundedLogic error$0
- NextGen: Artist signatures can be forged to impersonate the artist behind a collectionAccess control$0
- NextGen: `MinterContract::payArtist` can result in double the intended payoutLogic error$0