[Contract Verification] Verification error: Compilation error - without any detail #760

tradable-kash · 2024-11-05T17:16:34Z

tradable-kash
Nov 5, 2024

Team or Project

tradable

Environment

Testnet

Block Explorer

https://era.zksync.network/

Issue Type

Plugin
Block Explorer

Contract Address

0xD0Def0312B4C1545df5c9Aef91dE6DE4503daa5c

Compiler Type

Single file

zkSolc Version

1.5.4

Solc Version

0.8.27

Contract Name

Deal

Contract Code

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import { IERC6372 } from "@oz/contracts/interfaces/IERC6372.sol";
import { IERC20 } from "@oz/contracts/token/ERC20/IERC20.sol";
import { IERC20Metadata } from "@oz/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { Time } from "@oz/contracts/utils/types/Time.sol";
import { ERC20Upgradeable } from "@oz/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import { EnumerableSet } from "@oz/contracts/utils/structs/EnumerableSet.sol";
import { SafeCast } from "@oz/contracts/utils/math/SafeCast.sol";
import { FixedPointMathLib } from "@solady/utils/FixedPointMathLib.sol";

import { DEAL_MAX_HOLDERS } from "./Constants.sol";
import { IDeal } from "./interfaces/IDeal.sol";
import { IDealManager } from "./interfaces/IDealManager.sol";
import { IDealFactory } from "./interfaces/IDealFactory.sol";
import { Checkpoints } from "./libraries/Checkpoints.sol";

/**

@title Deal
@notice The Deal contract is responsible for tracking deal tokens, Net Asset Value (NAV), share prices, token
holders,
yield accumulation, and maintaining a list of eligible accounts for holding and transacting. Each Deal contract is
deployed per deal, with a strict 1-to-1 relationship between the Deal contract and the DealManager. The DealManager
exclusively controls this contract via the onlyManager modifier, ensuring that only the DealManager can modify the
contract's state.
@notice In addition to tracking holdings and yields, the Deal contract checks account eligibility for transfers and
minting. An account losing eligibility does not have a retroactive effect—such accounts may continue holding tokens,
but they will not be able to transact or acquire additional tokens. Tokens can still be burned from ineligible
accounts. The DealManager contract is always eligible for holding and transacting by default, without needing
explicit inclusion in the eligibility list. This contract ensures that holdings, eligibility checks, and burning
operations are correctly enforced while providing data for the DealManager to handle payout distributions.
Key Features:
- 1-to-1 Relationship with DealManager: The Deal contract is tightly coupled with a unique DealManager contract,
which has complete control over all state-modifying actions through the onlyManager modifier.
- Eligibility Management: The contract maintains a list of eligible accounts, restricting non-eligible accounts
from transacting or acquiring more tokens. If an account loses eligibility, it can still hold tokens, but cannot
participate in transfers or further token acquisitions.
- DealManager Auto-Eligibility: The DealManager contract is always eligible for holding and transacting tokens by
default, without needing to be explicitly added to the eligibility list.
- Burning from Ineligible Accounts: Even if an account is ineligible, tokens can always be burned from it,
ensuring flexibility in reducing total supply.
- Holdings and Yield Tracking with Second Precision: Tracks token holdings and calculates yields with
second-level
precision, providing the necessary data for the DealManager to execute payout distributions.
- NAV and Price Management: Tracks and updates the Net Asset Value (NAV) and share price, ensuring accurate and
up-to-date valuations of the deal’s assets.
- Token Operations: Facilitates minting, burning, and forced transfers of deal-specific tokens, under the control
of the DealManager, while enforcing eligibility rules for all token transfers.
- Fiat and Crypto Account Support: Manages both fiat and crypto accounts, allowing the DealManager to designate
accounts as fiat or remove them from the fiat list as needed.
- Maximum Holders Limit for Efficient Batch Operations: Enforces a maximum number of token holders to ensure that
batch operations, such as yield and payout calculations, do not exceed gas limits or lead to unbounded iterations,
thereby ensuring that operations fit within the block gas budget.
*/
contract Deal is IDeal, ERC20Upgradeable {
using FixedPointMathLib for *;
using SafeCast for uint256;
using Checkpoints for Checkpoints.Trace208;
using EnumerableSet for EnumerableSet.AddressSet;

/*//////////////////////////////////////////////////////////////////////////
                                 STORAGE
//////////////////////////////////////////////////////////////////////////*/

/// @param id The deal ID. Must not be mutated.
/// @param metadataURI The metadata URI.
/// @param totalSize The total size of the deal.
/// @param isOpenEnded Indicates whether the deal is open-ended (can be minted above the specified total size).
/// @param manager The deal manager contract.
/// @param nav The Net Asset Value (NAV) of the deal.
/// @param decimals The number of decimals for the deal token.
/// @param maxHolders The maximum number of holders allowed.
/// @param currentHolders The set of the holders who are actively holding tokens at the present time.
/// @param yieldRecipients The set of accounts that have ever held the token and received yield.
/// @param fiatAccounts The set of all fiat accounts that invested in the deal offchain.
/// @param eligibleAccounts The set of all eligible accounts that can participate in the deal.
/// @param totalYieldCheckpoints The total yield checkpoints.
/// @param accountYieldCheckpoints The yield checkpoints for each account.
struct DealStorage {
    string id;
    string metadataURI;
    uint256 totalSize;
    bool isOpenEnded;
    IDealManager manager;
    NAV nav;
    uint8 decimals;
    uint16 maxHolders;
    EnumerableSet.AddressSet currentHolders;
    EnumerableSet.AddressSet yieldRecipients;
    EnumerableSet.AddressSet fiatAccounts;
    EnumerableSet.AddressSet eligibleAccounts;
    Checkpoints.Trace208 totalYieldCheckpoints;
    mapping(address => Checkpoints.Trace208) accountYieldCheckpoints;
}

/// @custom:storage-location erc7201:tradable.storage.Deal
bytes32 private constant _DEAL_STORAGE_LOCATION = 0x27d89a09d922094b9e3c62601118cd681c0ddcd2c1d05164ec0d5aa24e223100;

/// @notice Resolve the storage slot.
function _storage() private pure returns (DealStorage storage $) {
    assembly {
        $.slot := _DEAL_STORAGE_LOCATION
    }
}

/*//////////////////////////////////////////////////////////////////////////
                               MODIFIERS
//////////////////////////////////////////////////////////////////////////*/

modifier onlyManager() {
    if (msg.sender != address(manager())) revert UnauthorizedAccount();
    _;
}

/// @notice Ensures the period is valid.
modifier assertValidPeriod(uint48 periodStartTime, uint48 periodEndTime) {
    if (periodStartTime >= periodEndTime) revert DealYieldInvalidPeriod(periodStartTime, periodEndTime);
    if (periodEndTime < yieldGenerationStart()) revert DealYieldPastLookup(periodEndTime, yieldGenerationStart());
    if (periodStartTime >= clock()) revert DealYieldFutureLookup(periodStartTime, clock());
    _;
}

/*//////////////////////////////////////////////////////////////////////////
                            PUBLIC FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/

/// @custom:oz-upgrades-unsafe-allow constructor
constructor() {
    _disableInitializers();
}

/// Deal initialization logic.
function initialize() external initializer {
    IDealFactory dealFactory = IDealFactory(msg.sender);
    IDealFactory.DealInitParams memory params = dealFactory.dealInitParams();
    if (bytes(params.config.id).length == 0) revert DealIdZeroLength();
    if (address(params.dealManager) == address(0)) revert DealManagerZeroAddress();

    __ERC20_init(params.config.tokenName, params.config.tokenSymbol);

    DealStorage storage $ = _storage();
    $.id = params.config.id;
    $.manager = params.dealManager;

    // The deal token inherits the decimals from the payment currency, to ensure correct scaling in calculations.
    $.decimals = params.paymentCurrency.decimals();
    $.nav.decimals = $.decimals;

    // Initialize configurable parameters.
    _setMaxHolders(DEAL_MAX_HOLDERS);
    _setMetadataURI(params.config.metadataURI);
    _setTotalSize(params.config.totalSize);
    _setOpenEnded(params.config.isOpenEnded);
}

/// @inheritdoc IDeal
function setMaxHolders(uint16 value) external onlyManager {
    _setMaxHolders(value);
}

/// @inheritdoc IDeal
function setNAV(uint256 value) external onlyManager {
    _setNAV(value);
}

/// @inheritdoc IDeal
function setMetadataURI(string calldata uri) external onlyManager {
    _setMetadataURI(uri);
}

/// @inheritdoc IDeal
function setTotalSize(uint256 value) external onlyManager {
    _setTotalSize(value);
}

/// @inheritdoc IDeal
function setOpenEnded(bool status) external onlyManager {
    _setOpenEnded(status);
}

/// @inheritdoc IDeal
function mint(Mint[] calldata targets) external onlyManager returns (uint256 totalMinted) {
    for (uint256 i = 0; i < targets.length; i++) {
        totalMinted += targets[i].amount;
        _mint(targets[i].to, targets[i].amount);
    }
}

/// @inheritdoc IDeal
function burn(Burn[] calldata targets) external onlyManager returns (uint256 totalBurned) {
    for (uint256 i = 0; i < targets.length; i++) {
        totalBurned += targets[i].amount;
        _burn(targets[i].from, targets[i].amount);
    }
}

/// @inheritdoc IDeal
function managedTransfer(address from, address to, uint256 amount) external onlyManager {
    _transfer(from, to, amount);
}

/// @inheritdoc IDeal
function addFiatAccounts(address[] calldata accounts) external onlyManager {
    DealStorage storage $ = _storage();
    for (uint256 i = 0; i < accounts.length; i++) {
        address account = accounts[i];
        if (account == address(0)) revert FiatAccountZeroAddress();
        if ($.fiatAccounts.add(account)) {
            emit AccountFiatStatusUpdated(account, true);
        }
    }
}

/// @inheritdoc IDeal
function removeFiatAccounts(address[] calldata accounts) external onlyManager {
    DealStorage storage $ = _storage();
    for (uint256 i = 0; i < accounts.length; i++) {
        address account = accounts[i];
        if ($.fiatAccounts.remove(account)) {
            emit AccountFiatStatusUpdated(account, false);
        }
    }
}

/// @inheritdoc IDeal
function addEligibleAccounts(address[] calldata accounts) external onlyManager {
    DealStorage storage $ = _storage();
    for (uint256 i = 0; i < accounts.length; i++) {
        address account = accounts[i];
        if (account == address(0)) revert EligibleAccountZeroAddress();
        if ($.eligibleAccounts.add(account)) {
            emit AccountEligibilityStatusUpdated(account, true);
        }
    }
}

/// @inheritdoc IDeal
function removeEligibleAccounts(address[] calldata accounts) external onlyManager {
    DealStorage storage $ = _storage();
    for (uint256 i = 0; i < accounts.length; i++) {
        address account = accounts[i];
        if ($.eligibleAccounts.remove(account)) {
            emit AccountEligibilityStatusUpdated(account, false);
        }
    }
}

/// @inheritdoc IERC6372
function clock() public view returns (uint48) {
    return Time.timestamp();
}

/// @inheritdoc IERC6372
// solhint-disable-next-line func-name-mixedcase
function CLOCK_MODE() public view returns (string memory) {
    if (clock() != Time.timestamp()) {
        revert ERC6372InconsistentClock();
    }
    return "mode=timestamp";
}

/// @inheritdoc IDeal
function id() external view returns (string memory) {
    return _storage().id;
}

/// @inheritdoc IDeal
function nav() external view returns (NAV memory) {
    return _storage().nav;
}

/// @notice Returns the deal share price.
function price() external view returns (Price memory) {
    DealStorage storage $ = _storage();
    uint48 navTimestamp = $.nav.timestamp;
    uint48 timestamp = navTimestamp;

    (bool exist, uint48 supplyUpdateTimestamp,) = $.totalYieldCheckpoints.latestCheckpoint();
    if (exist && supplyUpdateTimestamp > navTimestamp) {
        timestamp = supplyUpdateTimestamp;
    }

    uint256 totalSupply = totalSupply();
    uint256 priceValue = totalSupply > 0 ? $.nav.value.divWad(totalSupply) : 0;

    return Price({ value: priceValue, decimals: $.nav.decimals, timestamp: timestamp });
}

/// @inheritdoc IDeal
function metadataURI() external view returns (string memory) {
    return _storage().metadataURI;
}

/// @inheritdoc IDeal
function totalSize() external view returns (uint256) {
    return _storage().totalSize;
}

/// @inheritdoc IDeal
function isOpenEnded() external view returns (bool) {
    return _storage().isOpenEnded;
}

/// @inheritdoc IDeal
function maxHolders() external view returns (uint16) {
    return _storage().maxHolders;
}

/// @notice Approvals are disabled.
function approve(address, uint256) public pure override(ERC20Upgradeable, IERC20) returns (bool) {
    revert ERC20ApproveDisabled();
}

/// @notice Transfers are disabled.
function transfer(address, uint256) public pure override(ERC20Upgradeable, IERC20) returns (bool) {
    revert ERC20TransferDisabled();
}

/// @notice Transfers From are disabled.
function transferFrom(address, address, uint256) public pure override(ERC20Upgradeable, IERC20) returns (bool) {
    revert ERC20TransferFromDisabled();
}

/// @inheritdoc IDeal
function manager() public view returns (IDealManager) {
    return _storage().manager;
}

/// @inheritdoc IERC20Metadata
function decimals() public view override(ERC20Upgradeable, IERC20Metadata) returns (uint8) {
    return _storage().decimals;
}

/// @inheritdoc IDeal
function holders() external view returns (TokenHolder[] memory) {
    DealStorage storage $ = _storage();
    TokenHolder[] memory result = new TokenHolder[]($.currentHolders.length());
    for (uint256 i = 0; i < result.length; i++) {
        address account = $.currentHolders.at(i);
        uint256 balance = balanceOf(account);
        // forgefmt: disable-next-item
        result[i] = TokenHolder({
            account: account,
            balance: balance,
            isFiatAccount: $.fiatAccounts.contains(account)
        });
    }
    return result;
}

/// @inheritdoc IDeal
function holder(address account) external view returns (TokenHolder memory) {
    DealStorage storage $ = _storage();
    uint256 balance = balanceOf(account);
    return TokenHolder({ account: account, balance: balance, isFiatAccount: $.fiatAccounts.contains(account) });
}

/// @inheritdoc IDeal
function eligibleAccounts() external view returns (address[] memory) {
    return _storage().eligibleAccounts.values();
}

/// @inheritdoc IDeal
function isEligibleAccount(address account) public view returns (bool) {
    DealStorage storage $ = _storage();
    // Deal Manager is eligible by default, to ensure it can transact with the deal token.
    return $.eligibleAccounts.contains(account) || account == address($.manager);
}

/// @inheritdoc IDeal
function checkAccountEligibility(address account) public view {
    if (!isEligibleAccount(account)) revert AccountNotEligible(account);
}

/// @inheritdoc IDeal
function fiatAccounts() public view returns (address[] memory) {
    return _storage().fiatAccounts.values();
}

/// @inheritdoc IDeal
function isFiatAccount(address account) external view returns (bool) {
    return _storage().fiatAccounts.contains(account);
}

/// @inheritdoc IDeal
function fiatAccountsTotalYield(uint48 periodStartTime, uint48 periodEndTime) external view returns (uint256) {
    uint256[] memory yields = accountYield(periodStartTime, periodEndTime, fiatAccounts());
    uint256 total;
    for (uint256 i = 0; i < yields.length; i++) {
        total += yields[i];
    }
    return total;
}

/// @inheritdoc IDeal
function yieldGenerationStart() public view returns (uint48) {
    Checkpoints.Trace208 storage totalCheckpoints = _storage().totalYieldCheckpoints;
    if (totalCheckpoints.length() == 0) return 0;
    return totalCheckpoints.at(0)._key;
}

/// @inheritdoc IDeal
function accountYield(
    uint48 periodStartTime,
    uint48 periodEndTime,
    address[] memory accounts
)
    public
    view
    assertValidPeriod(periodStartTime, periodEndTime)
    returns (uint256[] memory yields)
{
    DealStorage storage $ = _storage();
    yields = new uint256[](accounts.length);
    for (uint256 i = 0; i < accounts.length; i++) {
        address account = accounts[i];
        // forgefmt: disable-next-item
        yields[i] = _yieldForPeriod(
            $.accountYieldCheckpoints[account],
            periodStartTime,
            periodEndTime,
            balanceOf(account)
        );
    }
}

/// @inheritdoc IDeal
function totalYield(
    uint48 periodStartTime,
    uint48 periodEndTime
)
    public
    view
    assertValidPeriod(periodStartTime, periodEndTime)
    returns (uint256)
{
    return _yieldForPeriod(_storage().totalYieldCheckpoints, periodStartTime, periodEndTime, totalSupply());
}

/// @notice Returns the yield distribution for a period.
/// @dev The yield is distributed pro rata based on the deal historical holding share of each holder in the period.
/// @dev CAUTION: This function is gas-intensive and should be used with caution in transactional contexts.
/// @param periodStartTime The start timestamp.
/// @param periodEndTime The end timestamp.
function yieldDistribution(
    uint48 periodStartTime,
    uint48 periodEndTime
)
    public
    view
    assertValidPeriod(periodStartTime, periodEndTime)
    returns (YieldRecipient[] memory yieldRecipients)
{
    DealStorage storage $ = _storage();
    yieldRecipients = new YieldRecipient[]($.yieldRecipients.length());
    uint256 recipientsCount = 0;
    for (uint256 i = 0; i < yieldRecipients.length; i++) {
        address account = $.yieldRecipients.at(i);
        uint256 yield =
            _yieldForPeriod($.accountYieldCheckpoints[account], periodStartTime, periodEndTime, balanceOf(account));

        if (yield > 0) {
            // forgefmt: disable-next-item
            yieldRecipients[recipientsCount++] = YieldRecipient({
                account: account,
                yield: yield,
                isFiatAccount: $.fiatAccounts.contains(account)
            });
        }
    }

    if (recipientsCount < yieldRecipients.length) {
        assembly {
            mstore(yieldRecipients, recipientsCount)
        }
    }
}

/*//////////////////////////////////////////////////////////////////////////
                           INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/

/// @inheritdoc ERC20Upgradeable
function _update(address from, address to, uint256 value) internal override {
    // Make sure the deal contract does not receive its own tokens.
    if (to == address(this)) revert DealContractCannotReceiveOwnTokens();

    uint256 fromBalanceBefore;
    uint256 toBalanceBefore;

    bool isMinting = from == address(0);
    bool isBurning = to == address(0);
    bool isTransfer = !isMinting && !isBurning;

    if (isTransfer) {
        checkAccountEligibility(from);
        checkAccountEligibility(to);
    }

    if (isMinting) {
        checkAccountEligibility(to);
        // Check if the total size is exceeded upon minting.
        if (!_storage().isOpenEnded) {
            uint256 totalDealSize = _storage().totalSize;
            if (totalSupply() + value > totalDealSize) revert TotalSizeExceeded(totalDealSize);
        }
    }

    // Create total yield checkpoint, when the total supply changes.
    if (isMinting || isBurning) {
        _createTotalYieldCheckpoint();
    }

    // Create a new account yield checkpoint for the sender, unless it is minting.
    if (!isMinting) {
        _createAccountYieldCheckpoint(from);
        fromBalanceBefore = balanceOf(from);
    }

    // Create a new account yield checkpoint for the recipient, unless it is burning.
    if (!isBurning) {
        _createAccountYieldCheckpoint(to);
        toBalanceBefore = balanceOf(to);
    }

    super._update(from, to, value);

    _afterBalanceUpdate(from, fromBalanceBefore);
    _afterBalanceUpdate(to, toBalanceBefore);
}

/*//////////////////////////////////////////////////////////////////////////
                           PRIVATE FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/

/// @notice Creates a new checkpoint for the yield of an account.
/// @param account The account to create the checkpoint for.
function _createAccountYieldCheckpoint(address account) private {
    DealStorage storage $ = _storage();
    $.yieldRecipients.add(account);
    uint208 yield = _createAccumulativeYieldCheckpoint($.accountYieldCheckpoints[account], balanceOf(account));
    emit AccountYieldUpdated(account, yield);
}

/// @notice Creates a new checkpoint for the total yield.
function _createTotalYieldCheckpoint() private {
    DealStorage storage $ = _storage();
    uint208 yield = _createAccumulativeYieldCheckpoint($.totalYieldCheckpoints, totalSupply());
    emit TotalYieldUpdated(yield);
}

/// @notice Updates the maximum number of holders allowed.
function _setMaxHolders(uint16 maxHolders_) private {
    DealStorage storage $ = _storage();
    emit MaxHoldersUpdated($.maxHolders, maxHolders_);
    $.maxHolders = maxHolders_;
}

/// @notice Updates the Net Asset Value (NAV) of the deal.
function _setNAV(uint256 navValue) private {
    DealStorage storage $ = _storage();
    emit NAVUpdated($.nav.value, navValue);
    $.nav.value = navValue;
    $.nav.timestamp = clock();
}

/// @notice Updates the metadata URI.
function _setMetadataURI(string memory metadataURI_) private {
    if (bytes(metadataURI_).length == 0) revert MetadataURIEmpty();
    DealStorage storage $ = _storage();
    emit MetadataURIUpdated($.metadataURI, metadataURI_);
    $.metadataURI = metadataURI_;
}

/// @notice Updates the total size of the deal.
function _setTotalSize(uint256 totalSize_) private {
    DealStorage storage $ = _storage();
    emit TotalSizeUpdated($.totalSize, totalSize_);
    $.totalSize = totalSize_;
}

/// @notice Updates the open-ended status of the deal.
function _setOpenEnded(bool isOpenEnded_) private {
    DealStorage storage $ = _storage();
    emit OpenEndedStatusUpdated(isOpenEnded_);
    $.isOpenEnded = isOpenEnded_;
}

/// @notice Creates a new checkpoint for the accumulative yield.
/// @param checkpoints The checkpoints to update.
/// @param tokenAmount The amount of tokens to calculate the yield for.
/// @return yield The yield for the period since the last checkpoint.
function _createAccumulativeYieldCheckpoint(
    Checkpoints.Trace208 storage checkpoints,
    uint256 tokenAmount
)
    private
    returns (uint208 yield)
{
    uint48 currentTimestamp = clock();
    (bool exists, uint48 prevTimestamp, uint208 prevCheckpointValue) = checkpoints.latestCheckpoint();
    if (!exists) {
        // slither-disable-next-line unused-return
        checkpoints.push(currentTimestamp, 0);
        return 0;
    }

    yield = SafeCast.toUint208((currentTimestamp - prevTimestamp) * tokenAmount);
    // slither-disable-next-line unused-return
    checkpoints.push(currentTimestamp, prevCheckpointValue + yield);
}

/// @notice Calculates the yield for a period.
/// @param checkpoints The checkpoints to calculate the yield for.
/// @param periodStartTime The start timestamp.
/// @param periodEndTime The end timestamp.
/// @param tokenBalance The token balance to calculate the yield for.
/// @return The yield for the period.
function _yieldForPeriod(
    Checkpoints.Trace208 storage checkpoints,
    uint48 periodStartTime,
    uint48 periodEndTime,
    uint256 tokenBalance
)
    private
    view
    returns (uint256)
{
    uint256 endValue = _yieldAt(checkpoints, periodEndTime, tokenBalance);
    if (periodStartTime == 0 || endValue == 0) return endValue;

    return endValue - _yieldAt(checkpoints, periodStartTime, tokenBalance);
}

/// @notice Returns the yield at a specific timestamp.
/// @param checkpoints The checkpoints to look up.
/// @param timestamp The timestamp to look up.
/// @param tokenBalance The token balance to calculate the yield for.
function _yieldAt(
    Checkpoints.Trace208 storage checkpoints,
    uint48 timestamp,
    uint256 tokenBalance
)
    private
    view
    returns (uint256)
{
    // If there are no checkpoints, return 0.
    if (checkpoints.length() == 0) return 0;

    // Find the closest checkpoint in the past or at the timestamp.
    (bool prevExists, uint48 prevTimestamp, uint208 prevValue, uint256 prevPos) =
        checkpoints.upperCheckpointLookup(timestamp);

    if (!prevExists) return 0;

    // Check if the timestamp exactly matches the closest checkpoint, no need to look further.
    if (timestamp == prevTimestamp) return prevValue;

    // Find the checkpoint past the timestamp.
    (bool nextExists, uint48 nextTimestamp, uint208 nextValue) = checkpoints.nextCheckpoint(prevPos);

    // If the is no future checkpoint, extrapolate the value up to the current timestamp, assuming linear growth.
    if (!nextExists) return prevValue + SafeCast.toUint208((timestamp - prevTimestamp) * tokenBalance);

    // The future checkpoint is always greater than the past checkpoint.
    assert(nextValue >= prevValue);

    // Interpolate the value between the two checkpoints.
    return (nextValue - prevValue).mulDiv(timestamp - prevTimestamp, nextTimestamp - prevTimestamp) + prevValue;
}

/// @notice Handles necessary updates after a balance change.
/// @dev This function updates the holder status and the total balance of fiat accounts.
/// @param account The account to update the status for.
/// @param balanceBefore The balance before the update.
function _afterBalanceUpdate(address account, uint256 balanceBefore) private {
    // Ignore the zero address.
    if (account == address(0)) return;

    // If the balance did not change, there is no need to update the holder status.
    uint256 balanceAfter = balanceOf(account);
    if (balanceBefore == balanceAfter) return;

    DealStorage storage $ = _storage();
    // Update the holder status.
    if(account != address($.manager)){
        if (balanceBefore == 0 && balanceAfter > 0) {
            // The balance is changed from zero, add the new holder, respecting the maximum holders limit.
            uint256 maxHoldersLimit = $.maxHolders;
            if ($.currentHolders.length() >= maxHoldersLimit) revert MaxHoldersExceeded(maxHoldersLimit);

            assert($.currentHolders.add(account));
            emit HolderStatusUpdated(account, true);
        } else if (balanceBefore > 0 && balanceAfter == 0) {
            // The balance is changed to zero, remove the holder.
            assert($.currentHolders.remove(account));
            emit HolderStatusUpdated(account, false);
        }
    }
}

}

Constructor Arguments

" "

Hardhat Verify Plugin Version

No response

Repo Link (Optional)

No response

Additional Details

Simply trying to verify-contract using forge verify-contract and getting compilation error of already deployed contract without additional info.
forge verify-contract --zksync --chain-id 300 --watch --num-of-optimizations 200 --verifier zksync --verifier-url https://explorer.sepolia.era.zksync.dev/contract_verification '0xD0Def0312B4C1545df5c9Aef91dE6DE4503daa5c' 'src/Deal.sol:Deal' Start verifying contract 0xD0Def0312B4C1545df5c9Aef91dE6DE4503daa5c` deployed on zksync-testnet

Submitting verification for [src/Deal.sol:Deal] at address 0xD0Def0312B4C1545df5c9Aef91dE6DE4503daa5c.
Verification submitted successfully. Verification ID: 31386
Checking verification status for ID: 31386 using verifier: zksync at URL: https://explorer.sepolia.era.zksync.dev/contract_verification
Error:
Verification error: Compilation error`

Answered by dutterbutter

Nov 5, 2024

No worries - working on a fix for foundry-zksync so verification errors are more verbose. Thanks for posting!

View full answer

2024-11-05T17:17:06Z

gleenai[bot]
bot Nov 5, 2024

It appears you are encountering a compilation error during the contract verification process on the ZKsync Testnet. This type of error typically indicates a mismatch or an issue with the contract's source code, compiler settings, or constructor arguments used during the deployment versus what is being used for verification.

Here are a few steps and checks you can perform to potentially resolve this issue:

Compiler Version and Settings: Ensure that the zkSolc version used for verification matches the one used during contract deployment. In your case, the version should be 1.5.4. Also, verify that the optimization settings and the number of runs (200 in your case) are consistent between deployment and verification.
Source Code Consistency: Make sure that the exact same source code and contract structure (src/Deal.sol:Deal) are used for both deployment and verification. Any changes or discrepancies can cause verification to fail.
Constructor Arguments: Double-check that the constructor arguments used during deployment are correctly specified during verification if your contract requires any. It seems your contract does not have constructor arguments, so ensure this is reflected correctly in the verification process.
Network and Address Accuracy: Confirm that the contract address 0xD0Def0312B4C1545df5c9Aef91dE6DE4503daa5c and the network settings (ZKsync Testnet, chain ID 300) are correctly specified.
Error Details: Since the error message "Compilation error" is quite generic, you might need more detailed logs or error messages to pinpoint the issue. Check if the verification tool or platform provides more detailed logs.

If after these checks the issue persists, I recommend reaching out to the ZKsync developer support or community forums with detailed information about your verification attempt, including the compiler version, contract source code, and any relevant deployment parameters. This can help in obtaining more specific guidance or identifying if there's a bug or issue with the verification tool itself.

For further discussions and support, you can visit the ZKsync developers discussions on Github.

Your feedback helps us serve you better. If this fully addresses your question, please give it a thumbs up. If it doesn't, please give it a thumbs down. This will inform the community and team so we can improve our support.

0 replies

dutterbutter · 2024-11-05T17:18:16Z

dutterbutter
Nov 5, 2024
Maintainer

@tradable-kash can you please update your foundry-zksync version by re-running the installation script: https://foundry-book.zksync.io/getting-started/installation#using-foundryup-zksync and try again. A recent fix addresses the compilation error during verification: matter-labs/foundry-zksync#690

If that does not work please provide a link to repo so that we can reproduce 🙏

4 replies

tradable-kash Nov 5, 2024
Author

yup i already did since i saw few threads regarding that and thought it would work too
foundryup-zksync: installing foundry (version nightly, tag nightly) foundryup-zksync: downloading latest forge, and cast ######################################################################################################################################################################### 100.0% foundryup-zksync: downloading manpages ######################################################################################################################################################################### 100.0% foundryup-zksync: installed - forge 0.0.2 (953a180 2024-11-05T00:24:47.804587000Z) foundryup-zksync: installed - cast 0.0.2 (953a180 2024-11-05T00:24:47.861780000Z) foundryup-zksync: done!

we are hosted on bitbucket [private repo], would that work? if yes then i will need your email-id to invite.

dutterbutter Nov 5, 2024
Maintainer

hmm looks like the issue isnt with evm_version but rather:

{"status":"failed","error":"Compilation error","compilationErrors":["DeclarationError: Identifier not found or not unique.\n  --> src/Deal.sol:54:20:\n   |\n54 | interface IDeal is IERC20Metadata, IERC6372 {\n   |

dutterbutter Nov 5, 2024
Maintainer

No worries - working on a fix for foundry-zksync so verification errors are more verbose. Thanks for posting!

Answer selected by tradable-kash

tradable-kash Nov 5, 2024
Author

All done on TestNet and MainNet :-)

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[Contract Verification] Verification error: Compilation error - without any detail #760

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Key Features:

Replies: 2 comments 4 replies

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

Select a reply

[Contract Verification] Verification error: Compilation error - without any detail #760

tradable-kash Nov 5, 2024

Team or Project

Environment

Block Explorer

Issue Type

Contract Address

Compiler Type

zkSolc Version

Solc Version

Contract Name

Contract Code

Key Features:

Constructor Arguments

Hardhat Verify Plugin Version

Repo Link (Optional)

Additional Details

Replies: 2 comments · 4 replies

gleenai[bot] bot Nov 5, 2024

dutterbutter Nov 5, 2024 Maintainer

tradable-kash Nov 5, 2024 Author

dutterbutter Nov 5, 2024 Maintainer

dutterbutter Nov 5, 2024 Maintainer

tradable-kash Nov 5, 2024 Author

tradable-kash
Nov 5, 2024

Replies: 2 comments 4 replies

gleenai[bot]
bot Nov 5, 2024

dutterbutter
Nov 5, 2024
Maintainer

tradable-kash Nov 5, 2024
Author

dutterbutter Nov 5, 2024
Maintainer

dutterbutter Nov 5, 2024
Maintainer

tradable-kash Nov 5, 2024
Author