Plasma Docs - Build on Plasma

前置条件

已部署在 Plasma 测试网上的合约。如果尚未部署，请参阅部署合约。
合约的源代码和编译设置。
部署时使用的构造函数参数（如果有）。

Plasma 区块浏览器（plasmascan.to）提供一个与 Etherscan 兼容的验证 API。下面的示例直接使用该 API——提交验证无需第三方账号。

示例合约

我们将使用两个示例合约，演示简单与复杂构造函数参数的情况：

简单合约

一个基础的数据存储合约，演示智能合约的基本概念。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract SimpleStorage {
    string private storedData;
    address public owner;
    
    constructor(string memory initialData) {
        storedData = initialData;
        owner = msg.sender;
    }
    
    function setData(string memory data) public {
        require(msg.sender == owner, "Only owner can set data");
        storedData = data;
    }
    
    function getData() public view returns (string memory) {
        return storedData;
    }
}

复杂合约

一个用于管理代币存款的更复杂的金库系统，带有可配置参数。

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

contract TokenVault {
    struct VaultConfig {
        uint256 minDeposit;
        uint256 maxDeposit;
        bool isActive;
    }
    
    address[] public authorisedTokens;
    VaultConfig public config;
    mapping(address => uint256) public balances;
    
    constructor(
        address[] memory _tokens,
        uint256 _minDeposit,
        uint256 _maxDeposit,
        bool _isActive
    ) {
        authorisedTokens = _tokens;
        config = VaultConfig(_minDeposit, _maxDeposit, _isActive);
    }
    
    function deposit(address token, uint256 amount) external {
        require(config.isActive, "Vault is not active");
        require(amount >= config.minDeposit, "Amount below minimum");
        require(amount <= config.maxDeposit, "Amount above maximum");
        balances[msg.sender] += amount;
    }
}

使用 Foundry 验证

Foundry 提供了 forge verify-contract 命令来验证合约。

确保你的 foundry.toml 包含验证所需的设置：

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc_version = "0.8.28"
optimizer = true
optimizer_runs = 200

[rpc_endpoints]
plasma_testnet = "https://testnet-rpc.plasma.to"

验证合约。对带有 string 构造函数参数的 SimpleStorage 合约：

forge verify-contract \
  --chain-id 9746 \
  --num-of-optimizations 200 \
  --watch \
  --constructor-args $(cast abi-encode "constructor(string)" "Hello, Plasma!") \
  --compiler-version v0.8.28+commit.7893614a \
  0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F \
  src/SimpleStorage.sol:SimpleStorage

对于含有多个构造函数参数的 TokenVault 合约：

# First, encode the constructor arguments.
CONSTRUCTOR_ARGS=$(cast abi-encode \
    "constructor(address[],uint256,uint256,bool)" \
    "[0x1234567890123456789012345678901234567890,0x0987654321098765432109876543210987654321]" \
    1000000000000000000 \
    10000000000000000000 \
    true)

forge verify-contract \
    --chain-id 9746 \
    --num-of-optimizations 200 \
    --watch \
    --constructor-args $CONSTRUCTOR_ARGS \
    --compiler-version v0.8.28+commit.7893614a \
    0x9876543210987654321098765432109876543210 \
    src/TokenVault.sol:TokenVault

查看验证状态。使用 --watch 标志时，Foundry 会显示实时验证状态。请关注如下输出：

Submitting verification for [src/SimpleStorage.sol:SimpleStorage] 0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F.
Submitted contract for verification:
        Response: `OK`
        GUID: `abc123def456ghi789`
        URL: https://testnet.plasmascan.to/address/0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F
Contract verification status:
Response: `NOTOK`
Details: `Pending in queue`
Contract verification status:
Response: `OK`
Details: `Pass - Verified`
Contract successfully verified

使用 Hardhat 验证

Hardhat 通过 @nomicfoundation/hardhat-verify 插件提供合约验证。

更新 hardhat.config.js，加入验证配置：

require("@nomicfoundation/hardhat-toolbox");
require("@nomicfoundation/hardhat-verify");
require("dotenv").config();

module.exports = {
  solidity: {
    version: "0.8.28",
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  },
  networks: {
    plasmaTestnet: {
      url: process.env.RPC_URL,
      chainId: 9746,
      accounts: [process.env.PRIVATE_KEY]
    }
  },
  etherscan: {
    customChains: [
      {
        network: "plasmaTestnet",
        chainId: 9746,
        urls: {
          apiURL: "https://testnet.plasmascan.to/api",
          browserURL: "https://testnet.plasmascan.to/"
        }
      }
    ]
  },
  sourcify: {
    enabled: false
  }
};

验证合约。对于简单合约：

npx hardhat verify \
    --network plasmaTestnet \
    0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F \
    "Hello, Plasma!"

对于含多个构造函数参数的合约，创建验证脚本 scripts/verify.js：

const hre = require("hardhat");

async function main() {
  const contractAddress = "0x9876543210987654321098765432109876543210";
  
  // Constructor arguments for TokenVault.
  const constructorArgs = [
    [
      "0x1234567890123456789012345678901234567890",
      "0x0987654321098765432109876543210987654321"
    ], // address[] _tokens
    "1000000000000000000", // uint256 _minDeposit (1e18, assuming 18 decimals)
    "10000000000000000000", // uint256 _maxDeposit (1e19, assuming 18 decimals)
    true // bool _isActive
  ];

  try {
    await hre.run("verify:verify", {
      address: contractAddress,
      constructorArguments: constructorArgs,
    });
    console.log("Contract verified successfully!");
  } catch (error) {
    console.error("Verification failed:", error);
  }
}

main()
  .then(() => process.exit(0))
  .catch((error) => {
    console.error(error);
    process.exit(1);
  });

运行验证脚本：

npx hardhat run scripts/verify.js --network plasmaTestnet

在部署过程中自动验证

你也可以在部署时一并自动验证合约：

const { ethers } = require("hardhat");

async function main() {
  const SimpleStorage = await ethers.getContractFactory("SimpleStorage");
  const simpleStorage = await SimpleStorage.deploy("Hello, Plasma!");
  
  await simpleStorage.waitForDeployment();
  const contractAddress = await simpleStorage.getAddress();
  
  console.log("SimpleStorage deployed to:", contractAddress);
  
  // Wait for a few block confirmations before verifying.
  console.log("Waiting for block confirmations...");
  await simpleStorage.deploymentTransaction().wait(5);
  
  // Verify the contract.
  try {
    await hre.run("verify:verify", {
      address: contractAddress,
      constructorArguments: ["Hello, Plasma!"],
    });
    console.log("Contract verified successfully!");
  } catch (error) {
    console.log("Verification failed:", error.message);
  }
}

main();

使用 Ethers.js 验证

Ethers.js 需要手动调用区块浏览器的 API 来验证。这种方式可以让你对验证流程拥有完全的控制权。

安装所需依赖：

npm install ethers dotenv axios form-data

创建验证脚本 verify-ethers.js：

const axios = require('axios');
const fs = require('fs');
require('dotenv').config();

async function verifyContract(contractAddress, sourceCode, contractName, constructorArgs = "") {
  const apiUrl = "https://testnet.plasmascan.to/api";
  
  const data = {
    module: 'contract',
    action: 'verifysourcecode',
    contractaddress: contractAddress,
    sourceCode: sourceCode,
    codeformat: 'solidity-single-file',
    contractname: contractName,
    compilerversion: 'v0.8.28+commit.7893614a',
    optimizationUsed: '1',
    runs: '200',
    constructorArguements: constructorArgs, // Note: API uses this spelling.
    evmversion: 'default',
    licenseType: '3' // MIT License
  };

  try {
    console.log('Submitting contract for verification...');
    const response = await axios.post(apiUrl, new URLSearchParams(data));
    
    if (response.data.status === '1') {
      const guid = response.data.result;
      console.log('Verification submitted successfully!');
      console.log('GUID:', guid);
      
      // Check verification status.
      await checkVerificationStatus(guid);
    } else {
      console.error('Verification submission failed:', response.data.result);
    }
  } catch (error) {
    console.error('Error submitting verification:', error.message);
  }
}

async function checkVerificationStatus(guid) {
  const apiUrl = "https://testnet.plasmascan.to/api";
  const maxAttempts = 30;
  let attempts = 0;

  while (attempts < maxAttempts) {
    try {
      const response = await axios.get(apiUrl, {
        params: {
          module: 'contract',
          action: 'checkverifystatus',
          guid: guid
        }
      });

      const status = response.data.status;
      const result = response.data.result;

      if (status === '1') {
        console.log('✅ Contract verified successfully!');
        console.log('Result:', result);
        break;
      } else if (result.includes('Fail')) {
        console.error('❌ Verification failed:', result);
        break;
      } else {
        console.log('⏳ Verification pending...');
        attempts++;
        
        if (attempts < maxAttempts) {
          await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds.
        }
      }
    } catch (error) {
      console.error('Error checking status:', error.message);
      break;
    }
  }

  if (attempts >= maxAttempts) {
    console.log('⚠️ Verification status check timed out. Please check manually.');
  }
}

// Verify SimpleStorage contract.
async function verifySimpleStorage() {
  const contractAddress = "0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F";
  const sourceCode = fs.readFileSync('SimpleStorage.sol', 'utf8');
  const constructorArgs = "0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000d48656c6c6f2c20506c61736d612100000000000000000000000000000000000000";
  
  await verifyContract(contractAddress, sourceCode, "SimpleStorage", constructorArgs);
}

// Verify TokenVault contract.
async function verifyTokenVault() {
  const contractAddress = "0x9876543210987654321098765432109876543210";
  const sourceCode = fs.readFileSync('TokenVault.sol', 'utf8');
  
  // Complex constructor arguments (ABI encoded).
  const constructorArgs = "0000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000de0b6b3a76400000000000000000000000000000000000000000000000000008ac7230489e8000000000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000123456789012345678901234567890123456789000000000000000000000000098765432109876543210987654321098765432100";
  
  await verifyContract(contractAddress, sourceCode, "TokenVault", constructorArgs);
}

// Run verification (uncomment the one you need).
verifySimpleStorage();
// verifyTokenVault();

编码构造函数参数。对于复杂构造函数参数，你需要对其进行 ABI 编码。可以使用 Foundry 的 cast 工具：

# For SimpleStorage with string argument.
cast abi-encode "constructor(string)" "Hello, Plasma!"

# For TokenVault with complex arguments.
cast abi-encode \
    "constructor(address[],uint256,uint256,bool)" \
    "[0x1234567890123456789012345678901234567890,0x0987654321098765432109876543210987654321]" \
    1000000000000000000 \
    10000000000000000000 \
    true

最后运行验证：
node verify-ethers.js

检查验证状态

验证后，你可以确认它是否成功：

在区块浏览器上

访问 Plasma 测试网区块浏览器。
搜索你的合约地址。
查看 “Contract” 标签旁是否有绿色对勾。
点击 “Contract” 标签查看已验证的源代码。

以编程方式

创建状态检查脚本 check-verification.js：

const axios = require('axios');
require('dotenv').config();

async function checkIfVerified(contractAddress) {
  const apiUrl = "https://testnet.plasmascan.to/api";
  
  try {
    const response = await axios.get(apiUrl, {
      params: {
        module: 'contract',
        action: 'getsourcecode',
        address: contractAddress,
      }
    });

    const result = response.data.result[0];
    
    if (result.SourceCode && result.SourceCode !== '') {
      console.log('✅ Contract is verified!');
      console.log('Contract Name:', result.ContractName);
      console.log('Compiler Version:', result.CompilerVersion);
      console.log('Optimisation Used:', result.OptimizationUsed);
      return true;
    } else {
      console.log('❌ Contract is not verified');
      return false;
    }
  } catch (error) {
    console.error('Error checking verification status:', error.message);
    return false;
  }
}

// Check your contract.
checkIfVerified("0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F");

备用方式

虽然区块浏览器是最常见的验证方式，你也可以使用：

Sourcify

Sourcify 提供去中心化的合约验证：

# Install Sourcify CLI.
npm install -g @ethereum-sourcify/cli

# Verify contract.
sourcify verify \
    --network 9746 \
    --address 0x742d35Cc6610C7532C8582d4C371Acb1D5f44D7F \
    --files contracts/SimpleStorage.sol

Tenderly

Tenderly 将验证作为其调试平台的一部分提供。详见其文档。

合约扁平化

对于含有导入或库的合约，你可能需要在验证前将合约扁平化为单个文件。常用工具包括：

对于带有外部库的复杂项目，请参阅 Hardhat 验证文档了解高级配置选项。

故障排查

构造函数参数不匹配

Error: Invalid constructor arguments provided

请仔细核对构造函数参数与部署时使用的参数完全一致。可使用 cast abi-encode 验证编码。

编译器版本不匹配

Error: Compilation failed

确保验证请求中的编译器版本与编译时使用的版本一致。

优化设置不匹配

Error: Bytecode doesn't match

校验优化设置（启用/禁用与运行次数）与你的编译设置一致。

已经验证

Error: Contract source code already verified

这意味着先前已成功验证过。请查看区块浏览器进行确认。

速率限制

Error: Rate limit exceeded

请稍等几分钟再重试。如果需要更高的限额，可以考虑升级 API 套餐。

开发

资产管理

网络配置

智能合约

测试与资源

验证合约

前置条件

示例合约

简单合约

复杂合约

使用 Foundry 验证

使用 Hardhat 验证

在部署过程中自动验证

使用 Ethers.js 验证

检查验证状态

在区块浏览器上

以编程方式

备用方式

Sourcify

Tenderly

合约扁平化

故障排查

构造函数参数不匹配

编译器版本不匹配

优化设置不匹配

已经验证

速率限制

​前置条件

​示例合约

​简单合约

​复杂合约

​使用 Foundry 验证

​使用 Hardhat 验证

​在部署过程中自动验证

​使用 Ethers.js 验证

​检查验证状态

​在区块浏览器上

​以编程方式

​备用方式

​Sourcify

​Tenderly

​合约扁平化

​故障排查

​构造函数参数不匹配

​编译器版本不匹配

​优化设置不匹配

​已经验证

​速率限制

前置条件

示例合约

简单合约

复杂合约

使用 Foundry 验证

使用 Hardhat 验证

在部署过程中自动验证

使用 Ethers.js 验证

检查验证状态

在区块浏览器上

以编程方式

备用方式

Sourcify

Tenderly

合约扁平化

故障排查

构造函数参数不匹配

编译器版本不匹配

优化设置不匹配

已经验证

速率限制