[Contract Verification] Inconsistency between ZK Explorer(explorer.sophon) verification vs Etherscan based(sophscan)

[VargaElod23]

Team or Project

Sophon

ZK chain

Sophon

Environment

Testnet

Block Explorer

ZKsync explorer (e.g. https://explorer.zksync.io)

Issue Type

• Plugin
• Block Explorer

Contract Address

0x3cC1c4814Bc5cC5906acC4e30b4bD48f7E337308

Compiler Type

Single file

zkSolc Version

v1.5.11

Solc Version

0.8.27

Contract Name

SPHNX

Contract Code

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

// File: SPHNX.sol

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
// SPDX-License-Identifier: MIT
pragma solidity  ^0.8.24;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        _requirePaused();
        _;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        require(paused(), "Pausable: not paused");
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: SPHNX.sol

pragma solidity ^0.8.13;



contract SPHNX is Ownable, Pausable, ReentrancyGuard {
    // State variables
    IERC20 public paymentToken;
    uint256 public messagePrice;
    uint256 public messagesProcessed;
    address public winner;
    
    // Variables for withdrawal splits
    uint256 private WINNER_SHARE;
    uint256 private OWNER_SHARE = 100- WINNER_SHARE;
      // State variables to track withdrawn amounts
mapping(address => bool) private hasWithdrawn;
    
    // Mapping to track user's paid messages
    mapping(address => uint256) public userMessages;
    // Mapping to track if a transaction hash has been used
    mapping(bytes32 => bool) public usedTransactionHashes;
    
    // Events
    event PaymentTokenChanged(address indexed newToken);
    event MessagePaid(address indexed user, uint256 amount, uint256 timestamp);
    event PriceUpdated(uint256 newPrice);
    event FundsWithdrawn(address indexed to, uint256 amount);
    event WinnerSet(address indexed winner);
    event WinnerWithdrawal(address indexed winner, uint256 amount);
    event OwnerWithdrawal(address indexed owner, uint256 amount);
    
    // Custom errors
    error InsufficientPayment();
    error TokenTransferFailed();
    error TransactionAlreadyUsed();
    error UnauthorizedWithdrawal();
    error WithdrawalFailed();
    error NoWinnerSet();
    error InvalidAmount();
    error AlreadyWithdrawn();
    
    constructor(address _initialToken, uint256 _initialPrice, uint256 _WINNER_SHARE) Ownable(msg.sender) {
        paymentToken = IERC20(_initialToken);
        messagePrice = _initialPrice;
WINNER_SHARE = _WINNER_SHARE;
    }
    /**
     * @dev Set the payment token
     * @param _newToken The address of the payment token
     */
    function setPaymentToken(address _newToken) external onlyOwner {
        paymentToken = IERC20(_newToken);
        emit PaymentTokenChanged(_newToken);
    }

    /**
     * @dev Set the winner address
     * @param _winner The address of the winner
     */
    function setWinner(address _winner) external onlyOwner {
        require(_winner != address(0), "Invalid winner address");
        winner = _winner;
        emit WinnerSet(_winner);
    }
    
    /**
     * @dev Pay for a message
     */
    function payForMessage() external payable nonReentrant whenNotPaused {
        // Checks
        if (paymentToken.balanceOf(msg.sender) < messagePrice) {
            revert InsufficientPayment();
        }
        
        bytes32 txHash = keccak256(abi.encodePacked(msg.sender, block.timestamp));
        if (usedTransactionHashes[txHash]) {
            revert TransactionAlreadyUsed();
        }
        
        // Effects
        usedTransactionHashes[txHash] = true;
        userMessages[msg.sender]++;
        messagesProcessed++;
        
        // Interactions
        bool success = paymentToken.transferFrom(msg.sender, address(this), messagePrice);
        if (!success) {
            revert TokenTransferFailed();
        }
        
        emit MessagePaid(msg.sender, messagePrice, block.timestamp);
    }
    
    /**
     * @dev Update the price per message
     * @param newPrice The new price in wei
     */
    function updatePrice(uint256 newPrice) external onlyOwner {
        messagePrice = newPrice;
        emit PriceUpdated(newPrice);
    }
    
    /**
     * @dev Get the number of messages a user has paid for
     * @param user The address to check
     */
    function getMessageCount(address user) external view returns (uint256) {
        return userMessages[user];
    }
    
    /**
     * @dev Check if a specific transaction hash has been used
     * @param txHash The hash to check
     */
    function isTransactionUsed(bytes32 txHash) external view returns (bool) {
        return usedTransactionHashes[txHash];
    }



/**
 * @dev Internal function to process token withdrawals
 * Note: State changes should be done before calling this
 */
function _processWithdrawal(address to, uint256 amount) private {
    bool success = paymentToken.transfer(to, amount);
    if (!success) {
        revert WithdrawalFailed();
    }
    
    emit FundsWithdrawn(to, amount);
}

/**
 * @dev Withdraw tokens according to role (winner or owner)
 */
function withdraw() external nonReentrant {
    // Checks
    uint256 tokenBalance = paymentToken.balanceOf(address(this));
    if (tokenBalance == 0) revert InvalidAmount();
    if (hasWithdrawn[msg.sender]) revert AlreadyWithdrawn();
    
    uint256 amount;
    if (msg.sender == winner) {
        if (winner == address(0)) revert NoWinnerSet();
        amount = (tokenBalance * WINNER_SHARE) / 100;
    } else if (msg.sender == owner()) {
        amount = (tokenBalance * OWNER_SHARE) / 100;
    } else {
        revert UnauthorizedWithdrawal();
    }

    // Effects
    hasWithdrawn[msg.sender] = true;

    // Interactions
    _processWithdrawal(msg.sender, amount);
    
    // Events after successful transfer
    if (msg.sender == winner) {
        emit WinnerWithdrawal(winner, amount);
    } else {
        emit OwnerWithdrawal(owner(), amount);
    }
}
/**
 * @dev Reset withdrawal status for a specific address (only owner)
 */
function resetWithdrawalStatus(address account) external onlyOwner {
    hasWithdrawn[account] = false;
}

    
    /**
     * @dev Get contract balance
     */
   function getBalance() external view returns (uint256) {
    return paymentToken.balanceOf(address(this));
}
/**
 * @dev Allow owner to withdraw accidentally sent ETH
 */
function withdrawETH() external nonReentrant onlyOwner {
    uint256 balance = address(this).balance;
    if (balance == 0) revert InvalidAmount();
    
    (bool success, ) = owner().call{value: balance}("");
    if (!success) {
        revert WithdrawalFailed();
    }
    
  
}

// Allow contract to receive ETH
receive() external payable {

}

// Allow contract to receive ETH via fallback
fallback() external payable {
   
}

    /**
     * @dev Pause contract
     */
    function pause() external onlyOwner {
        _pause();
    }

    /**
     * @dev Unpause contract
     */
    function unpause() external onlyOwner {
        _unpause();
    }
    
    
}

Constructor Arguments

0000000000000000000000006acd42121fa31b3bb517537c7f2ed3c512c6b37c000000000000000000000000000000000000000000000000000000000003d0900000000000000000000000000000000000000000000000000000000000000046

-----Decoded View---------------
Arg [0] : _initialToken (address): [0x6Acd42121fA31B3bB517537C7f2Ed3c512C6B37c](https://testnet.sophscan.xyz/address/0x6Acd42121fA31B3bB517537C7f2Ed3c512C6B37c)
Arg [1] : _initialPrice (uint256): 250000
Arg [2] : _WINNER_SHARE (uint256): 70

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000006acd42121fa31b3bb517537c7f2ed3c512c6b37c
Arg [1] : 000000000000000000000000000000000000000000000000000000000003d090
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000046

Hardhat Verify Plugin Version

2.0.9

Repo Link (Optional)

https://github.com/ndehouche/SPHNX_SOPHON

Additional Details

The bytecode at https://testnet.sophscan.xyz/address/0x3cC1c4814Bc5cC5906acC4e30b4bD48f7E337308#code is identical to the one at https://explorer.testnet.sophon.xyz/address/0x3cC1c4814Bc5cC5906acC4e30b4bD48f7E337308 but if you take the exact same verified code and constructor arguments in the former and paste it on the latter, you either hit the solc version error above, or it produces a different bytecode if you downgrade to 8.24.

[ndehouche]

Moreover, we get the same issue with a generic greeter contract.

• It deployed and verified impeccably on Sophscan at https://testnet.sophscan.xyz/address/0x56e9fd8991506f6bc79a7e2e3c2c2a471fbb62ac#code
• The same bytecode is recognized by Explorer.Sophon.xyz at https://explorer.testnet.sophon.xyz/address/0x56E9fD8991506f6bc79a7e2E3C2C2a471fBb62aC#contract
• When copying and pasting the same source code from Sophscan to Explorer.Sophon.xyz, I get "Deployed bytecode is not equal to generated one from given source".
• The same error appears on the CLI:
  

[dimazhornyk]

Doing it through UI is not the best option because you can't know the underlying issues and some configurations are not supported there, e.g. "evmVersion": "paris" that can be seen on Sophscan can't be set via UI on explorer.sophon.xyz

And it seems like the code on Sophscan is different from what you have in the repo.
Also, I wasn't able to get a similar bytecode locally by compiling the source code from Sophscan.

Please ensure that your repo's content is enough to reproduce the issue or get the same bytecodes. And please share your verification steps, commands/scripts you used

[MexicanAce]

In addition, @ndehouche can you please attempt to verify from the CLI by doing the following:

1. Update hardhat.config.ts to disable using Etherscan

etherscan: {
  enabled: false,
// ...

2. yarn hardhat verify --network sophonTestnet 0x56e9fd8991506f6bc79a7e2e3c2c2a471fbb62ac 0000000000000000000000006acd42121fa31b3bb517537c7f2ed3c512c6b37c000000000000000000000000000000000000000000000000000000000003d0900000000000000000000000000000000000000000000000000000000000000046

[ndehouche]

Doing it through UI is not the best option because you can't know the underlying issues and some configurations are not supported there, e.g. "evmVersion": "paris" that can be seen on Sophscan can't be set via UI on explorer.sophon.xyz

And it seems like the code on Sophscan is different from what you have in the repo. Also, I wasn't able to get a similar bytecode locally by compiling the source code from Sophscan.

Please ensure that your repo's content is enough to reproduce the issue or get the same bytecodes. And please share your verification steps, commands/scripts you used

Please note that the GUI verification attempt was after attempting to initially verify through the CLI (though there are potential issue with the GUI that can be worth investigating. More on this below).

CLI Verification

Here is a barebones example, the following empty contract, at "/contract/test.sol":

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
contract Test {

}

This is deploy.ts:

import { Provider, Wallet, utils } from "zksync-ethers";
import { Deployer } from "@matterlabs/hardhat-zksync-deploy";
import { HardhatRuntimeEnvironment } from "hardhat/types";

export default async function(hre: HardhatRuntimeEnvironment) {
    const provider = new Provider(hre.network.config.url);
    const wallet = new Wallet(process.env.WALLET_PRIVATE_KEY!, provider);
    const deployer = new Deployer(hre, wallet);
    const artifact = await deployer.loadArtifact("Test");

 

    const params = utils.getPaymasterParams(
      "0x98546B226dbbA8230cf620635a1e4ab01F6A99B2", // Paymaster address
      {
        type: "General",
        innerInput: new Uint8Array(),
      }
    );

    const contract = await deployer.deploy(
      artifact,
      [], // Convert to uint256 with correct decimals
      undefined, // Deployment type (use undefined for regular contract deployment)
      {
          customData: {
              paymasterParams: params,
              gasPerPubdata: utils.DEFAULT_GAS_PER_PUBDATA_LIMIT,
          }
      }
  );

}

and this is hardhat.config:

import type { HardhatUserConfig } from "hardhat/config";

import "@matterlabs/hardhat-zksync";
import * as dotenv from "dotenv";

// Load environment variables from .env file
dotenv.config();

const config: HardhatUserConfig = {
  defaultNetwork: "sophonTestnet",
  networks: {
    hardhat: {
      zksync: true,
    },
    sophonMainnet: {
      url: "https://rpc.sophon.xyz",
      ethNetwork: "mainnet",
      verifyURL: "https://verification-explorer.sophon.xyz/contract_verification",
      browserVerifyURL: "https://explorer.sophon.xyz/",
      enableVerifyURL: true,
      zksync: true,
      accounts: [process.env.WALLET_PRIVATE_KEY as string],
    },
    sophonTestnet: {
      url: "https://rpc.testnet.sophon.xyz",
      ethNetwork: "sepolia",
      verifyURL: "https://api-explorer-verify.testnet.sophon.xyz/contract_verification",
      browserVerifyURL: "https://explorer.testnet.sophon.xyz/",
      enableVerifyURL: true,
      zksync: true,
      accounts: [process.env.WALLET_PRIVATE_KEY as string],
    },
  },
  zksolc: {
    version: "latest",
    settings: {},
  },
  solidity: {
    version: "0.8.27",
  },
  etherscan: {
    enabled: true,
    apiKey: {
      sophonTestnet: process.env.ETHERSCAN_SOPHON_API_KEY as string,
      sophonMainnet: process.env.ETHERSCAN_SOPHON_API_KEY as string,
    },
    customChains: [
      {
        network: "sophonTestnet",
        chainId: 531050104,
        urls: {
          apiURL: "https://api-testnet.sophscan.xyz/api",
          browserURL: "https://testnet.sophscan.xyz",
        },
      },
      {
        network: "sophonMainnet",
        chainId: 50104,
        urls: {
          apiURL: "https://api.sophscan.xyz/api",
          browserURL: "https://sophscan.xyz",
        },
      },
    ],
  },
};

export default config;

Running yarn hardhat verify --network sophonTestnet 0x185912ccF5196E82b5c2ac9F95DC598aC22ab644, the contract successfully verifies on Sophscan, but not Explorer.Sophon. I get:

Your verification ID is: vrlq1nxhrzhxqbzwcsrkqxyjq1nnsgcquc3hhnx6w5r7guyrwj
Successfully verified contract contracts/test.sol:Test on the block explorer.
        https://testnet.sophscan.xyz/address/0x185912ccF5196E82b5c2ac9F95DC598aC22ab644#code

Your verification ID is: 946
hardhat-zksync-verify found one or more errors during the verification process:

ZkSyncBlockExplorer:
Failed to send contract verification request
 Reason: ZkSyncVerifyPluginError: Deployed bytecode is not equal to generated one from given source

GUI Issues

Please note again that this is after the CLI verification attempt.

1. The deployed bytecode recognized at https://testnet.sophscan.xyz/address/0x185912ccF5196E82b5c2ac9F95DC598aC22ab644#code is identical to the one at https://explorer.testnet.sophon.xyz/address/0x185912ccF5196E82b5c2ac9F95DC598aC22ab644#contract
   However, when pasting the code from the former in https://explorer.testnet.sophon.xyz/contracts/verify?address=0x185912ccF5196E82b5c2ac9F95DC598aC22ab644 with the right parameters, I get the same error as in the CLI:
   

2. Independently of which contract you are trying to verify, whenever I select a solc version >0.8.24, I get the error zksolc error: solcversions >0.8.24 are not supported, found 0.8.28, despite versions >0.8.24 being choices in the dropdown menu.
   See following images with the zero address for example:
   

[ndehouche]

2. 0000000000000000000000006acd42121fa31b3bb517537c7f2ed3c512c6b37c000000000000000000000000000000000000000000000000000000000003d0900000000000000000000000000000000000000000000000000000000000000046

This fails on explorer.sophon with the message:

ZkSyncBlockExplorer:
The address provided as argument contains a contract, but its bytecode doesn't match any of your local contracts.

      Possible causes are:
        - Contract code changed after the deployment was executed. This includes code for seemingly unrelated contracts.
        - A solidity file was added, moved, deleted or renamed after the deployment was executed. This includes files for seemingly unrelated contracts.
        - Solidity compiler settings were modified after the deployment was executed (like the optimizer, target EVM, etc.).
        - The given address is wrong.
        - The selected network is wrong.

When I re-enable Etherscan, verification also fails there with the same message.
When I use yarn hardhat verify --network sophonTestnet 0x56e9fd8991506f6bc79a7e2e3c2c2a471fbb62ac hello, it succeeds on Etherscan but fails on explorer.sophon, with the usual Reason: ZkSyncVerifyPluginError: Deployed bytecode is not equal to generated one from given source

[popzxc]

I've investigated this problem deeply and found the following issues:

The repo you have provided doesn't match the configuration for verification on sophonscan. I've made the following changes to the hardhat configuration:

  zksolc: {
    version: "1.5.11",
    settings: {
      "optimizer": {
        "enabled": true,
        "mode": "3"
      },
      "forceEVMLA": false,
      "enableEraVMExtensions": false,
      "libraries": {}
    },
  },
  solidity: {
    version: "0.8.27",
    settings: {
      "evmVersion": "paris"
    }
  },

In particular:

• changed zksolc version from latest to 1.5.11
• added settings for zksolc taken from sophonscan
• added paris EVM version to solc configuration (again, from sophonscan).

With that, I was able to get matching bytecode except for metadata hash.

Now, the metadata hash depends on many things (including file names, paths, and explicitly passed configuration settings). So, to recreate the exact metadata hash, we must know the initial setup in which contract was compiled. I tried a few hypotheses, but wasn't able to "guess" the configuration that led to the correct metadata hash.

Since recently, ZKsync explorer supports partial verification (verification for contracts with correct bytecode but incorrect metadata hash).
Hardhat plugin had a bug that did not allow verifying contracts with incorrect metadata, I've opened a PR to fix it, it should be merged soon.

For now, I used my local version of hardhat and was able to verify your contract.
Obviously, it's listed as partially verified, because metadata hash does not match.
If you will be able to recreate the exact environment in which contract was deployed, you will be able to do full verification.

So, tl;dr:

• Passing correct settings for the compiler is important
• Preserving the exact structure (settings + project layout) is important for full verification
• Partial matching wasn't supported before, but it is now.
• The contract mentioned in the question is now verified.

I'm going to mark this as answered, feel free to unmark it (it's important) or start a new discussion if you feel that something wasn't resolved here.