[Contract Verification] Verification error: Compilation error

[mikhailcheburkahtin]

Team or Project

Tradable

Environment

Testnet

Block Explorer

https://era.zksync.network/

Issue Type

• Plugin
• Block Explorer

Contract Address

0xDF249f087C3ACfc381D810A38CC5C7055A5E0F52

Compiler Type

Single file

zkSolc Version

1.5.4

Solc Version

0.8.27

Contract Name

DealManager

Contract Code

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

import { AccessManagedUpgradeable } from "@oz/contracts-upgradeable/access/manager/AccessManagedUpgradeable.sol";
import { IERC20Metadata } from "@oz/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import { SafeERC20 } from "@oz/contracts/token/ERC20/utils/SafeERC20.sol";
import { Initializable } from "@oz/contracts-upgradeable/proxy/utils/Initializable.sol";

import { IBaseManager, BaseManager, IKYCManager } from "./abstracts/BaseManager.sol";
import { IInvestmentManager, InvestmentManager } from "./abstracts/InvestmentManager.sol";
import { IPayoutManager, PayoutManager } from "./abstracts/PayoutManager.sol";
import { IDealManager } from "./interfaces/IDealManager.sol";
import { IRedemptionManager } from "./interfaces/manager/IRedemptionManager.sol";
import { IDeal } from "./interfaces/IDeal.sol";
import { IDealFactory } from "./interfaces/IDealFactory.sol";
import { BasisPoints } from "./types/BasisPoints.sol";

/**

• @title DealManager
• @notice The DealManager contract is deployed per deal, establishing a 1-to-1 relationship between a Deal token
• contract and its corresponding DealManager. Each instance of DealManager is responsible for managing a single deal,
• including investment offers, payouts, and token operations. It serves as the core contract for deal
• management, integrating multiple responsibilities such as access control, KYC verification, and payout processing,
• ensuring that all deal-related operations are handled within a dedicated and isolated environment.
• @notice This contract implements the IDealManager interface and inherits functionality from several modules:
• • AccessManaged: Controls access management and authority delegation.
• • BaseManager: Manages capital and fee recipients, and handles currency conversion related to deals.
• • KYCManager: Manages KYC verification and eligibility for deal participation.
• • InvestmentManager: Manages investment offers.
• • RedemptionManager: Manages redemption requests.
• • PayoutManager: Oversees payout distribution to deal participants and manages balances and fees.

• Key Features:

• • Dedicated Deal Management: Each DealManager is responsible for a single deal, ensuring isolated and focused
• management of all deal-related operations.
• • Multi-Role Management: Efficiently integrates access management, capital allocation, KYC, and payout
• distribution under one unified contract.
• • Token Operations: Supports minting, burning, and transferring deal-specific tokens, enabling flexible
• distribution to participants.
• • KYC Verification: Ensures that only eligible participants, as verified by a KYC process, can engage in deals.
• • Investments Handling: Manages investment offers, escrow periods, and origination fees, providing a streamlined
• and secure investment process.
• • Redemption Handling: Manages investor redemption requests, allowing investors to redeem their tokens under
• predefined conditions.
• • Pro Rata Payouts: Distributes both principal and interest payouts to participants based on their share in the
• deal.
• • Service Fee Management: Automatically calculates and applies service fees during payouts, offering transparency
• and accountability.
• • Comprehensive Payout Tracking: Supports tracking of payout balances, ensuring that participants can claim or
• receive payouts based on their deal involvement.
• • Fiat and Crypto Support: Seamlessly handles both fiat and on-chain accounts, allowing for flexibility in deal
• participation and payouts.
  */
  contract DealManager is
  Initializable,
  AccessManagedUpgradeable,
  BaseManager,
  InvestmentManager,
  PayoutManager,
  IDealManager
  {
  using SafeERC20 for IERC20Metadata;

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

/// @notice Ensures the available funds are sufficient for the operation.
modifier hasSufficientAvailableFunds(uint256 amount) {
    uint256 available = availableFunds();
    if (available < amount) revert InsufficientFunds(available, amount);
    _;
}

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

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

/// @notice Initializes the proxy contract.
function initialize() external initializer {
    IDealFactory dealFactory = IDealFactory(msg.sender);
    IDealFactory.DealManagerInitParams memory params = dealFactory.dealManagerInitParams();

    __AccessManaged_init(dealFactory.authority());
    __BaseManager_init(
        params.deal, params.config.paymentCurrency, params.config.capitalRecipient, params.config.feeRecipient
    );
    __PayoutManager_init(params.config.serviceFee);
    __InvestmentManager_init(params.config.originationFee, params.config.redemptionFee, params.config.minInvestment);
}

/// @inheritdoc IBaseManager
function withdrawFundsToCapitalRecipient(uint256 amount) external restricted hasSufficientAvailableFunds(amount) {
    address recipient = capitalRecipient();
    if (recipient == address(0)) revert CapitalRecipientZeroAddress();

    paymentCurrency().safeTransfer(recipient, amount);
}

/// @inheritdoc IBaseManager
function setCapitalRecipient(address recipient) external restricted {
    _setCapitalRecipient(recipient);
}

/// @inheritdoc IBaseManager
function setFeeRecipient(address recipient) external restricted {
    _setFeeRecipient(recipient);
}

/// @inheritdoc IInvestmentManager
function setMinInvestment(uint256 amount) external restricted {
    _setMinInvestment(amount);
}

/// @inheritdoc IInvestmentManager
function setOriginationFee(BasisPoints fee) external restricted {
    _setOriginationFee(fee);
}

/// @inheritdoc IInvestmentManager
function setOfferEscrowPeriod(uint48 period) external restricted {
    _setOfferEscrowPeriod(period);
}

/// @inheritdoc IInvestmentManager
function submitOffer(uint256 amount, uint256 maxFee) external returns (InvestmentOffer memory offer) {
    return _submitOffer(amount, maxFee);
}

/// @inheritdoc IInvestmentManager
function cancelOffer(uint256 id) external onlyOfferInvestor(id) {
    _cancelOffer(id);
}

/// @inheritdoc IInvestmentManager
function reviewOffer(uint256 id, uint256 acceptedAmount) external restricted {
    _reviewOffer(id, acceptedAmount);
}

/// @inheritdoc IPayoutManager
function setServiceFee(BasisPoints fee) external restricted {
    _setServiceFee(fee);
}

/// @inheritdoc IPayoutManager
function initiatePrincipalPayout(
    string calldata payoutId,
    uint256 totalPayoutAmount
)
    external
    restricted
    ensureUniquePayoutId(payoutId)
    returns (uint256, uint256)
{
    return _initiatePrincipalPayout(payoutId, totalPayoutAmount, availableFunds(), _afterPrincipalPayout);
}

/// @inheritdoc IPayoutManager
function initiateInterestPayout(
    string calldata payoutId,
    uint256 onchainPayoutAmount,
    uint48 periodEndTime
)
    external
    restricted
    ensureUniquePayoutId(payoutId)
    hasSufficientAvailableFunds(onchainPayoutAmount)
    returns (uint256, uint256)
{
    return _initiateInterestPayout(payoutId, onchainPayoutAmount, periodEndTime);
}

/// @inheritdoc IPayoutManager
function pushPayout(address[] calldata accounts) external restricted {
    _pushPayout(accounts);
}

/// @inheritdoc IPayoutManager
function revokePayout(address account) external restricted {
    _revokePayout(account);
}

/// @inheritdoc IDealManager
function addDealFiatAccounts(address[] calldata accounts) external restricted {
    deal().addFiatAccounts(accounts);
}

/// @inheritdoc IDealManager
function removeDealFiatAccounts(address[] calldata accounts) external restricted {
    deal().removeFiatAccounts(accounts);
}

/// @inheritdoc IKYCManager
function addDealEligibleAccounts(address[] calldata accounts) external restricted {
    deal().addEligibleAccounts(accounts);
}

/// @inheritdoc IKYCManager
function removeDealEligibleAccounts(address[] calldata accounts) external restricted {
    deal().removeEligibleAccounts(accounts);
    for (uint256 i = 0; i < accounts.length; i++) {
        _deleteRedemptionRequest(accounts[i]);
    }
}

/// @inheritdoc IDealManager
function mintDealTokens(IDeal.Mint[] calldata targets)
    external
    restricted
    returns (uint256 totalMinted, uint256 eligibleCount)
{
    IDeal.Mint[] memory eligibleTargets = new IDeal.Mint[](targets.length);
    for (uint256 i = 0; i < targets.length; i++) {
        if (!isEligibleAccount(targets[i].to)) {
            emit TokenMintSkippedIneligible(targets[i].to, targets[i].amount);
            continue;
        }
        eligibleTargets[eligibleCount++] = targets[i];
    }

    if (eligibleCount > 0) {
        if (eligibleCount < targets.length) {
            assembly {
                mstore(eligibleTargets, eligibleCount)
            }
        }
        totalMinted = deal().mint(eligibleTargets);
    }
    emit TokensMinted(totalMinted);
}

/// @inheritdoc IDealManager
function burnDealTokens(IDeal.Burn[] calldata targets) external restricted returns (uint256 totalBurned) {
    IDeal dealToken = deal();
    totalBurned = dealToken.burn(targets);
    emit TokensBurned(totalBurned);

    for (uint256 i = 0; i < targets.length; ++i) {
        _decreaseRedemptionAmount(targets[i].from, dealToken.balanceOf(targets[i].from));
    }
}

/// @inheritdoc IDealManager
function transferDealTokens(address from, address to, uint256 amount) external restricted {
    deal().managedTransfer(from, to, amount);
    _afterTransfer(from, to, amount);
}

/// @inheritdoc IDealManager
function setDealNAV(uint256 nav) external restricted {
    deal().setNAV(nav);
}

/// @inheritdoc IDealManager
function setDealMetadataURI(string calldata metadataURI) external restricted {
    deal().setMetadataURI(metadataURI);
}

/// @inheritdoc IDealManager
function setDealTotalSize(uint256 totalSize) external restricted {
    deal().setTotalSize(totalSize);
}

/// @inheritdoc IDealManager
function setDealOpenEnded(bool status) external restricted {
    deal().setOpenEnded(status);
}

/// @inheritdoc IDealManager
function setDealMaxHolders(uint16 maxHolders) external restricted {
    deal().setMaxHolders(maxHolders);
}

/// @inheritdoc IRedemptionManager
function setRedemptionFee(BasisPoints fee) external restricted {
    _setRedemptionFee(fee);
}

/// @inheritdoc IRedemptionManager
function setRedemptionLockPeriod(uint48 period) external restricted {
    _setRedemptionLockPeriod(period);
}

/// @inheritdoc IRedemptionManager
/// @dev We cannot use `hasSufficientAvailableFunds` here because the current budget must be factored in as well.
function setRedemptionBudget(uint256 budget) external restricted {
    uint256 available = availableFunds() + redemptionBudget();
    if (available < budget) revert InsufficientFunds(available, budget);
    _setRedemptionBudget(budget);
}

/// @inheritdoc IRedemptionManager
function submitRedemptionRequest(uint256 amount, uint256 maxFee) external returns (RedemptionRequest memory) {
    return _submitRedemptionRequest(msg.sender, amount, maxFee);
}

/// @inheritdoc IRedemptionManager
function relayRedemptionRequest(
    address investor,
    uint256 amount
)
    external
    restricted
    returns (RedemptionRequest memory)
{
    // Check if the account is a fiat account.
    // The redemption request cannot be relayed for non-fiat accounts.
    if (!deal().isFiatAccount(investor)) revert RelayingRedemptionRequestForNonFiatAccount(investor);

    // Current fees accepted automatically.
    return _submitRedemptionRequest(investor, amount, calculateRedemptionFee(amount));
}

/// @inheritdoc IRedemptionManager
function reviewRedemptionRequest(uint256 id, uint256 acceptedAmount) external restricted {
    _reviewRedemptionRequest(id, acceptedAmount);
}

/// @inheritdoc IRedemptionManager
function cancelRedemptionRequest(uint256 id) external onlyRequestedInvestor(id) {
    _cancelRedemptionRequest(id);
}

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

/// @inheritdoc IDealManager
function availableFunds() public view returns (uint256) {
    uint256 lockedBalance = reservedFunds();
    uint256 totalBalance = paymentCurrency().balanceOf(address(this));
    if (totalBalance <= lockedBalance) return 0;

    return totalBalance - lockedBalance;
}

/// @inheritdoc IDealManager
/// @dev The reserved funds include escrowed investment offers, unclaimed payouts, and other locked funds which make
/// them unavailable for originator withdrawal.
function reservedFunds() public view returns (uint256 locked) {
    locked += PayoutManager.totalPayoutBalance();
    locked += InvestmentManager.totalEscrowBalance();
    locked += InvestmentManager.redemptionBudget();
}

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

/// @notice Principal payout callback function.
function _afterPrincipalPayout(IPayoutManager.PrincipalPayout memory payout) internal {
    _decreaseRedemptionAmount(payout.account, payout.newTokenBalance);
}

/// @notice Transfer callback function.
function _afterTransfer(address from, address, uint256) internal {
    _decreaseRedemptionAmount(from, deal().balanceOf(from));
}

}

Constructor Arguments

" "

Hardhat Verify Plugin Version

No response

Repo Link (Optional)

No response

Additional Details

Trying to verify contract using forge but getting compilation error
command used:
forge verify-contract --zksync --chain-id 300 --watch --num-of-optimizations 200 --verifier zksync --verifier-url https://explorer.sepolia.era.zksync.dev/contract_verification '0x914C727FbA5Beeafcc587fD72A4c1F864451382E' 'src/DealManager.sol:DealManager'
output:
Start verifying contract 0x914C727FbA5Beeafcc587fD72A4c1F864451382E` deployed on zksync-testnet

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

[gleenai[bot]]

It appears you are encountering a compilation error while trying to verify your DealManager contract on the ZKsync testnet using Forge. Here are a few steps and checks you can perform to potentially resolve this issue:

1. Compiler Version Compatibility: Ensure that the zkSolc version specified (1.5.4) and the Solc version (0.8.27) are compatible with the contract code and the Forge version you are using. Sometimes, discrepancies in compiler versions can lead to compilation errors.

2. Contract Code Review: Review the contract code for any syntax errors or dependencies that might not be properly addressed or compatible with the ZKsync environment. This includes checking all imports and inherited contracts for compatibility issues.

3. Constructor Arguments: You mentioned that the constructor arguments are empty (" "). If your contract's initialization requires specific parameters, ensure they are correctly provided. If the contract uses an initializer instead of a constructor (common in upgradeable contracts), make sure the initialization process is correctly handled post-deployment.

4. Optimization Settings: The --num-of-optimizations 200 flag sets the optimizer runs. Verify if this level of optimization is compatible with your contract. Sometimes, too much or too little optimization can affect the bytecode generation.

5. Verification Command: Double-check the verification command for any typos or incorrect parameters. Also, ensure that the --verifier-url is correct and accessible.

6. Network and Address Check: Confirm that the contract address 0x914C727FbA5Beeafcc587fD72A4c1F864451382E and the network settings in your verification command match where the contract is actually deployed.

If after these checks the issue persists, you might want to consider reaching out for more specific support. You can engage with the ZKsync developer community on GitHub discussions for more in-depth troubleshooting.

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.

[dutterbutter]

@mikhailcheburkahtin hello 👋

Looks like the issue is coming from here:

{"status":"failed","error":"Compilation error","compilationErrors":["TypeError: Definition of base has to precede definition of derived contract\n  --> src/interfaces/IDealManager.sol:15:5:\n   |\n15 |     IBaseManager,\n   |     ^^^^^^^^^^^^\n\n"]}

Specifically,

The compilation error you're encountering is due to a Solidity restriction: when you declare a derived contract, the base contracts must be defined in a specific order in your inheritance hierarchy. The base contract should appear before the derived contract in the inheritance list.

In your DealManager contract, you have multiple inheritance:

contract DealManager is
    Initializable,
    AccessManagedUpgradeable,
    BaseManager,            // <-- This should be listed before any contract that depends on it
    InvestmentManager,
    PayoutManager,
    IDealManager

Check if InvestmentManager or PayoutManager depends on BaseManager. If they do, then BaseManager should come before those contracts in the inheritance list.

Suggested Fix

• Rearrange your inheritance hierarchy by placing BaseManager before any contracts that might extend it (like InvestmentManager or PayoutManager).

For example, if InvestmentManager and PayoutManager rely on BaseManager, your inheritance should look like this:

contract DealManager is
    Initializable,
    AccessManagedUpgradeable,
    BaseManager,
    InvestmentManager,
    PayoutManager,
    IDealManager
{
    // Contract code...
}

This should resolve the compilation error. If not let me know !

I am in the process of updating foundry-zksync verification error verbosity so thank you for reporting!

--- Update ----

• PR to add more verbosity: fix: add verbosity for verification compilation error matter-labs/foundry-zksync#703

[tradable-kash]

looking forward to more verbose error message so we only help you chase signals.
on the above error though - whats baffling is it compiled well locally and the order is correct InvestmentManager/PayoutManager depends on BaseManager and thus they are below

i had a doubt on flattening - perhaps thats where the order is getting rearranged and BaseManager goes below

[dutterbutter]

PR for verbosity has been merged, please update your foundry-zksync version by re-running the installation script here.

@tradable-kash are you still experiencing the issue when not using flattening? Flattening is not supported using forge verify-contract against ZKsync block explorer instance. It is supported when using Etherscan ZKsync verification.

For instance, using ZKsync block explorer instance:

forge verify-contract --zksync --verifier zksync --rpc-url https://sepolia.era.zksync.dev/ --verifier-url https://explorer.sepolia.era.zksync.dev/contract_verification <CONTRACT-ADDRESS> <path>:<contractname>

[dutterbutter]

You can also make use of the explorer verification UI for flatten verification: https://sepolia.explorer.zksync.io/contracts/verify . If used, specify the solc version used as zkVM-0.8.27-1.0.1 and the applicable zksolc version (likely 1.5.4 if used with foundry).