[Contract Verification] Cannot verify NonFungibleTokenPositionDescriptorAddressV1_3_0 deployed via uniswap-zksync/era-uniswap-deploy-v3 (Abstract Testnet)

[stephankmin]

Environment

Testnet

Block Explorer

https://explorer.zksync.io/

Issue Type

• Plugin
• Block Explorer

Contract Address

0xD533950c2be73B8146BA81877f91a845F0879E13

Compiler Type

Multi-part contract

zkSolc Version

1.3.13

Solc Version

0.7.6

Contract Name

NonfungibleTokenPositionDescriptor

Contract Code

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity =0.7.6;
pragma abicoder v2;

import '@uniswap/v3-core/contracts/interfaces/IUniswapV3Pool.sol';
import '@uniswap/lib/contracts/libraries/SafeERC20Namer.sol';

import './libraries/ChainId.sol';
import './interfaces/INonfungiblePositionManager.sol';
import './interfaces/INonfungibleTokenPositionDescriptor.sol';
import './interfaces/IERC20Metadata.sol';
import './libraries/PoolAddress.sol';
import './libraries/NFTDescriptor.sol';
import './libraries/TokenRatioSortOrder.sol';

/// @title Describes NFT token positions
/// @notice Produces a string containing the data URI for a JSON metadata string
contract NonfungibleTokenPositionDescriptor is INonfungibleTokenPositionDescriptor {
address private constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
address private constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address private constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
address private constant TBTC = 0x8dAEBADE922dF735c38C80C7eBD708Af50815fAa;
address private constant WBTC = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;

address public immutable WETH9;
/// @dev A null-terminated string
bytes32 public immutable nativeCurrencyLabelBytes;

constructor(address _WETH9, bytes32 _nativeCurrencyLabelBytes) {
    WETH9 = _WETH9;
    nativeCurrencyLabelBytes = _nativeCurrencyLabelBytes;
}

/// @notice Returns the native currency label as a string
function nativeCurrencyLabel() public view returns (string memory) {
    uint256 len = 0;
    while (len < 32 && nativeCurrencyLabelBytes[len] != 0) {
        len++;
    }
    bytes memory b = new bytes(len);
    for (uint256 i = 0; i < len; i++) {
        b[i] = nativeCurrencyLabelBytes[i];
    }
    return string(b);
}

/// @inheritdoc INonfungibleTokenPositionDescriptor
function tokenURI(INonfungiblePositionManager positionManager, uint256 tokenId)
    external
    view
    override
    returns (string memory)
{
    (, , address token0, address token1, uint24 fee, int24 tickLower, int24 tickUpper, , , , , ) =
        positionManager.positions(tokenId);

    IUniswapV3Pool pool =
        IUniswapV3Pool(
            PoolAddress.computeAddress(
                positionManager.factory(),
                PoolAddress.PoolKey({token0: token0, token1: token1, fee: fee})
            )
        );

    bool _flipRatio = flipRatio(token0, token1, ChainId.get());
    address quoteTokenAddress = !_flipRatio ? token1 : token0;
    address baseTokenAddress = !_flipRatio ? token0 : token1;
    (, int24 tick, , , , , ) = pool.slot0();

    return
        NFTDescriptor.constructTokenURI(
            NFTDescriptor.ConstructTokenURIParams({
                tokenId: tokenId,
                quoteTokenAddress: quoteTokenAddress,
                baseTokenAddress: baseTokenAddress,
                quoteTokenSymbol: quoteTokenAddress == WETH9
                    ? nativeCurrencyLabel()
                    : SafeERC20Namer.tokenSymbol(quoteTokenAddress),
                baseTokenSymbol: baseTokenAddress == WETH9
                    ? nativeCurrencyLabel()
                    : SafeERC20Namer.tokenSymbol(baseTokenAddress),
                quoteTokenDecimals: IERC20Metadata(quoteTokenAddress).decimals(),
                baseTokenDecimals: IERC20Metadata(baseTokenAddress).decimals(),
                flipRatio: _flipRatio,
                tickLower: tickLower,
                tickUpper: tickUpper,
                tickCurrent: tick,
                tickSpacing: pool.tickSpacing(),
                fee: fee,
                poolAddress: address(pool)
            })
        );
}

function flipRatio(
    address token0,
    address token1,
    uint256 chainId
) public view returns (bool) {
    return tokenRatioPriority(token0, chainId) > tokenRatioPriority(token1, chainId);
}

function tokenRatioPriority(address token, uint256 chainId) public view returns (int256) {
    if (token == WETH9) {
        return TokenRatioSortOrder.DENOMINATOR;
    }
    if (chainId == 1) {
        if (token == USDC) {
            return TokenRatioSortOrder.NUMERATOR_MOST;
        } else if (token == USDT) {
            return TokenRatioSortOrder.NUMERATOR_MORE;
        } else if (token == DAI) {
            return TokenRatioSortOrder.NUMERATOR;
        } else if (token == TBTC) {
            return TokenRatioSortOrder.DENOMINATOR_MORE;
        } else if (token == WBTC) {
            return TokenRatioSortOrder.DENOMINATOR_MOST;
        } else {
            return 0;
        }
    }
    return 0;
}

}

Constructor Arguments

0x740810c5CB6a562BC0F4F387dC7cFaDa9f3A7ebf
0x4554480000000000000000000000000000000000000000000000000000000000

Hardhat Verify Plugin Version

No response

Repo Link (Optional)

https://github.com/uniswap-zksync/era-uniswap-v3-periphery/tree/v1.3.0-zksync-era

Additional Details

I deployed uniswap-zksync v3 to Abstract testnet by following the instructions in uniswap-zksync/era-uniswap-deploy-v3.

Deployment and verification worked perfectly for all contracts except one that I couldn't verify, NonfungibleTokenPositionDescriptor.sol.

I've tried verifying via hardhat plugin from both the v1.1.1-zksync-era and v1.3.0-zksync-era branches, but neither branch seems to have bytecode matching the contract that gets deployed from uniswap-zksync/era-uniswap-deploy-v3.

This is the command I am running:
yarn hardhat verify --network abstractTestnet 0xD533950c2be73B8146BA81877f91a845F0879E13 "0x740810c5CB6a562BC0F4F387dC7cFaDa9f3A7ebf" "0x4554480000000000000000000000000000000000000000000000000000000000"

This is my config for Abstract testnet that I've defined in hardhat.config.ts:

abstractTestnet: {
      url: 'https://api.testnet.abs.xyz',
      ethNetwork: 'https://api.testnet.abs.xyz',
      zksync: true,
      verifyURL: 'https://api-explorer-verify.testnet.abs.xyz/contract_verification',
    }

Can you please share the steps taken to verify this same contract on zkSync Mainnet?

Thank you!

[gleenai[bot]]

It seems you are encountering issues with verifying the NonfungibleTokenPositionDescriptor contract on the Abstract testnet using the Hardhat plugin. The problem might be related to the compatibility of the zkSolc version or the specific configurations in your Hardhat setup.

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

1. zkSolc Version Compatibility: Ensure that the zkSolc version (1.3.13) you are using is supported by the Hardhat plugin. If there are compatibility issues, consider using a different version of zkSolc that is known to work with the plugin.

2. Bytecode Matching: Double-check that the bytecode of the deployed contract matches the expected bytecode from the compilation. Differences in compiler settings, such as optimization and EVM version, can cause discrepancies.

3. Constructor Arguments: Verify that the constructor arguments are correctly formatted and match those expected by the contract. Incorrect constructor arguments can lead to a mismatch during verification.

4. Network Configuration: Ensure that your network configuration in hardhat.config.ts is correctly set up for the Abstract testnet. This includes the url, ethNetwork, and verifyURL.

5. Plugin Version: Use the recommended version of the Hardhat verify plugin that is known to work with your contract's setup. Sometimes, newer or older versions of the plugin might have issues with specific contracts or network configurations.

6. Manual Verification: If automated tools fail, you might consider manually verifying the contract by comparing the deployed bytecode with the locally compiled bytecode and ensuring all parameters and settings align.

For a more detailed guide on verifying contracts using Hardhat, you can refer to the ZKsync documentation on contract verification with Hardhat here.

If these steps do not resolve the issue, it might be helpful to reach out to the support or community forums for the specific tools and networks you are using, as they might have more context-specific insights or updates.

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.

[bxpana]

If the answer above didn't help you would you mind downvoting it so the bot can learn?

[bxpana]

What error did you get when trying to verify it? Were you able to test manually verifying it through their block explorer UI? https://explorer.testnet.abs.xyz/contracts/verify

[stephankmin]

here is the full error trace:

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.

For more info run Hardhat with --show-stack-traces
error Command failed with exit code 1.

I was having trouble verifying manually because the block explorer wouldn't recognize some dependencies.

[bxpana]

Have you checked to see if this is working correctly on ZKsync Era? If you're able to verify on ZKsync Era then we know that it's something specifically with Abstract.

[stephankmin]

hey @bxpana my apologies for the late folllow up on this thread.

I tried deploying and verifying this same contract on Zksync Era and I'm getting the same error that I got above on Abstract Mainnet and Testnet.

We also compared this contract's bytecode on Abstract Mainnet with the canonical NonFungibleTokenPositionDescriptor deployed on Zksync Era using the following script and there are some differences in bytecode. It looks like the deployment script in era-uniswap-deploy-v3 deploys a slightly different contract than the canonical version.

Here is the diff:

diff ab_op zk_op
diff --git 1/ab_op 2/zk_op
index 5f7d077..e30348e 100644
--- 1/ab_op
+++ 2/zk_op
@@ -24880,19 +24880,17 @@ STOP
 STOP
 STOP
STOP
-ADDRESS
-UNKNOWN_cf
-ORIGIN
-PUSH7 0x240021f101e388
-UNKNOWN_d9
-UNKNOWN_b8
-MULMOD
-MSIZE
-UNKNOWN_c4
-UNKNOWN_2c
-MOD
-DUP13
-PUSH29 0x00000000000000000000000000
+PUSH30 0x67b8ff4abffc020641f5e430fbee
+UNKNOWN_d0
+CODESIZE
+SWAP8
+PUSH8 0x4d00000000000000
+STOP
+STOP
+STOP
+STOP
+STOP
+STOP
 STOP
 STOP
 STOP

Is there anyone on the team that can help us look into this? Thanks so much

[AntonD3]

@stephankmin I believe the issue is that you need to specify the NFTDescriptor library address, it's an external library so we are setting it in the runtime in the deploy script https://github.com/uniswap-zksync/era-uniswap-deploy-v3/blob/zksync-era/src/steps/deploy-nft-position-descriptor-v1_3_0.ts#L10 and then recompiling it.

But you can just add it to the hardhat config like this: https://docs.zksync.io/zksync-era/tooling/hardhat/guides/compiling-libraries#manual-deployment and rerun verification.

Regarding the bytecode difference - I think your script trying to parse the bytecode as an EVM bytecode, but it's EraVM bytecode. I believe there should be only one difference - a different library address. Can you try to compare bytecodes without parsing(like hex strings)? Then I guess you should see only this addresses the difference.

[stephankmin]

thanks @AntonD3 verification worked after I added the library address, will look into the bytecode script