OpenZeppelin Hardhat Upgrades API

deployProxy 和 upgradeProxy 函数都将返回 ethers.js contracts 的实例，并且需要 ethers.js contract factories 作为参数。对于 beacons，deployBeacon 和 upgradeBeacon 都将返回一个可升级的 beacon 实例，该实例可以与 beacon proxy 一起使用。所有部署和升级函数都会验证 implementation contract 是否 upgrade-safe，否则将失败。

常用选项

以下选项是一些函数的通用选项。

kind: ("uups" | "transparent" | "beacon") 要部署、升级或导入的代理的类型，或 implementation 将使用的代理的类型。deployProxy() 和 upgradeProxy() 仅支持 "uups" | "transparent" 值。默认为 "transparent"。请参阅 Transparent vs UUPS。
unsafeAllow: (ValidationError[]) 有选择地禁用一个或多个验证错误或警告：
- "external-library-linking"：允许部署链接到 implementation contract 的外部库。（外部库目前尚不支持。）
- "struct-definition", "enum-definition"：过去需要使用 structs 或 enums 部署 contract。现在不再需要。
- "state-variable-assignment"：允许在一个 contract 中分配状态变量，即使它们将存储在 implementation 中。
- "state-variable-immutable"：允许使用 immutable 变量，这些变量是安全的
- "constructor"：允许定义构造函数。请参阅 constructorArgs。
- "delegatecall", "selfdestruct"：允许使用这些操作。不正确地使用此选项可能会导致资金永久损失的风险。请参阅我可以安全地使用 delegatecall 和 selfdestruct 吗？
- "missing-public-upgradeto"：允许不包含公共 upgradeTo 或 upgradeToAndCall 函数的 UUPS implementations。启用此选项很可能导致由于内置的 UUPS 安全机制而导致 revert。
- "internal-function-storage"：允许在存储变量中使用内部函数。内部函数是指针，升级后将不再有效，因此必须在升级期间重新分配。请参阅如何在存储变量中使用内部函数？
- "missing-initializer"：允许未检测到 initializer 函数的 implementations。
- "missing-initializer-call"：允许子 initializer 未调用父 initializer 的 implementations。
- "duplicate-initializer-call"：允许子 initializer 多次调用父 initializer 的 implementations。
- "incorrect-initializer-order"：允许未按线性化顺序调用父 initializers 的 implementations。注意：默认情况下，此条件会显示警告，并且设置此选项将消除警告。
unsafeAllowRenames: (boolean) 配置存储布局检查以允许变量重命名。
unsafeSkipStorageCheck: (boolean) 升级代理或 beacon，而不首先检查存储布局兼容性错误。这是一个危险的选项，旨在用作最后的手段。
constructorArgs: (unknown[]) 提供 implementation contract 构造函数的参数。请注意，这些参数与 initializer 参数不同，将用于 implementation contract 本身的部署中。可用于初始化 immutable 变量。
initialOwner: (string) 要设置为 transparent proxy 的管理员的初始所有者地址或 beacon 的初始所有者地址。默认为部署 transparent proxy 或 beacon 的外部拥有的帐户。不支持 UUPS proxies。
- 始于: @openzeppelin/hardhat-upgrades@3.0.0
unsafeSkipProxyAdminCheck: (boolean) 部署 transparent proxy 时跳过检查 initialOwner 选项。部署 transparent proxy 时，initialOwner 必须是 EOA 的地址或可以在 ProxyAdmin 上调用函数的 contract。它不能是 ProxyAdmin contract 本身。如果您遇到由于此检查而导致的错误，并且确定 initialOwner 不是 ProxyAdmin contract，请使用此选项。
- 始于: @openzeppelin/hardhat-upgrades@3.4.0
timeout: (number) 部署 implementation contract 时等待交易确认的超时时间（以毫秒为单位）。默认为 60000。使用 0 无限期等待。
pollingInterval: (number) 部署 implementation contract 时检查交易确认的轮询间隔（以毫秒为单位）。默认为 5000。
redeployImplementation: ("always" | "never" | "onchange") 确定是否将重新部署 implementation contract。默认为 "onchange"。
- 如果设置为 "always"，即使 implementation contract 先前已使用相同的 bytecode 部署，也会始终重新部署 implementation contract。这可以与通过 OpenZeppelin Defender 部署代理时的 salt 选项一起使用，以确保 implementation contract 使用与代理相同的 salt 部署。
- 如果设置为 "never"，则永远不会重新部署 implementation contract。如果 implementation contract 先前未部署或在网络文件中未找到，则会引发错误。
- 如果设置为 "onchange"，则仅当 bytecode 与之前的部署相比发生更改时，才会重新部署 implementation contract。
txOverrides: (ethers.Overrides) 一个 ethers.js Overrides 对象，用于覆盖交易参数，例如 gasLimit 和 gasPrice。应用于具有此选项的函数发送的所有交易，即使该函数发送了多个交易。对于 OpenZeppelin Defender 部署，仅支持 gasLimit、gasPrice、maxFeePerGas 和 maxPriorityFeePerGas 参数。
useDefenderDeploy: (boolean) 使用 OpenZeppelin Defender 而不是 ethers.js 部署 contracts。请参阅与 OpenZeppelin Defender 一起使用。
verifySourceCode: (boolean) 使用 OpenZeppelin Defender 部署时，是否在区块浏览器上验证源代码。默认为 true。
relayerId: (string) 使用 OpenZeppelin Defender 部署时，用于部署的中继器的 ID。默认为在 Defender 上为您的部署环境配置的中继器。
salt: (string) 使用 OpenZeppelin Defender 部署时，如果未设置，将使用 CREATE 操作码执行部署。如果已设置，将使用 CREATE2 操作码以及提供的 salt 执行部署。请注意，使用 Safe 的部署是使用 CREATE2 完成的，并且需要 salt。警告： CREATE2 影响 msg.sender 行为。有关更多信息，请参阅注意事项。
metadata: ({ commitHash?: string; tag?: string; [k: string]: any; }) 使用 OpenZeppelin Defender 部署时，您可以使用它来标识、标记或分类部署。请参阅元数据。
proxyFactory: (ethers.ContractFactory) 自定义用于部署代理的 ethers contract factory，允许部署自定义代理 contract。有关每种代理类型的默认 contract factory，请参阅 factories.ts。
- 始于: @openzeppelin/hardhat-upgrades@3.7.0
deployFunction: ((hre, opts, factory, …args) ⇒ Promise<EthersOrDefenderDeployment>) 自定义用于部署代理的函数。可以与 proxyFactory 选项一起使用，以覆盖自定义代理部署的构造函数参数。有关默认部署函数，请参阅 deploy.ts。
- 始于: @openzeppelin/hardhat-upgrades@3.7.0

请注意，如果使用 Solidity >=0.8.2，也可以更精细地直接在源代码中指定 unsafeAllow 选项。请参阅如何禁用某些检查？

以下选项已被弃用。

unsafeAllowLinkedLibraries: 等同于在 unsafeAllow 中包含 "external-library-linking"。
unsafeAllowCustomTypes: 等同于在 unsafeAllow 中包含 "struct-definition" 和 "enum-definition"。现在不再需要。
useDeployedImplementation: (boolean) 等同于将 redeployImplementation 设置为 "never"。

deployProxy

async function deployProxy(
  Contract: ethers.ContractFactory,
  args: unknown[] = [],
  opts?: {
    initializer?: string | false,
    unsafeAllow?: ValidationError[],
    constructorArgs?: unknown[],
    initialOwner?: string,
    unsafeSkipProxyAdminCheck?: boolean,
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
    kind?: 'uups' | 'transparent',
    useDefenderDeploy?: boolean,
    proxyFactory?: ethers.ContractFactory,
    deployFunction?: () => Promise<EthersOrDefenderDeployment>,
  },
): Promise<ethers.Contract>

给定一个 ethers contract factory 用作 implementation，创建一个 UUPS 或 Transparent proxy，并返回一个具有代理地址和 implementation 接口的 contract 实例。如果设置了 args，将在代理部署期间使用提供的 args 调用 initializer 函数 initialize。

如果对同一 implementation contract 多次调用 deployProxy，将部署多个 proxies，但只会使用一个 implementation contract。

参数：

Contract - 一个 ethers contract factory 用作 implementation。
args - initializer 函数的参数。
opts - 具有选项的对象：
- initializer: 设置要调用的其他 initializer 函数（请参阅指定片段），或者指定 false 以禁用初始化。
- 常用选项中描述的其他选项。

返回值：

一个具有代理地址和 implementation 接口的 contract 实例。

upgradeProxy

async function upgradeProxy(
  proxy: string | ethers.Contract,
  Contract: ethers.ContractFactory,
  opts?: {
    call?: string | { fn: string; args?: unknown[] },
    unsafeAllow?: ValidationError[],
    unsafeAllowRenames?: boolean,
    unsafeSkipStorageCheck?: boolean,
    constructorArgs?: unknown[],
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
    kind?: 'uups' | 'transparent',
  },
): Promise<ethers.Contract>

将指定地址的 UUPS 或 Transparent proxy 升级到新的 implementation contract，并返回一个具有代理地址和新 implementation 接口的 contract 实例。

参数：

proxy - 代理地址或代理 contract 实例。
Contract - 一个 ethers contract factory 用作新的 implementation。
opts - 具有选项的对象：
- call: 启用在升级过程中执行任意函数调用。此调用使用函数名称、签名或选择器（请参阅指定片段）和可选参数进行描述。它被批处理到升级交易中，从而可以安全地调用迁移初始化函数。
- 常用选项中描述的其他选项。

返回值：

一个具有代理地址和新 implementation 接口的 contract 实例。

deployBeacon

async function deployBeacon(
  Contract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    constructorArgs?: unknown[],
    initialOwner?: string,
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
  },
): Promise<ethers.Contract>

给定一个 ethers contract factory 用作 implementation，创建一个 upgradable beacon，并返回 beacon contract 实例。

参数：

Contract - 一个 ethers contract factory 用作 implementation。
opts - 具有选项的对象：
- 常用选项中描述的其他选项。

返回值：

beacon contract 实例。

始于：

@openzeppelin/hardhat-upgrades@1.13.0

upgradeBeacon

async function upgradeBeacon(
  beacon: string | ethers.Contract,
  Contract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    unsafeAllowRenames?: boolean,
    unsafeSkipStorageCheck?: boolean,
    constructorArgs?: unknown[],
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
  },
): Promise<ethers.Contract>

将指定地址的 upgradable beacon 升级到新的 implementation contract，并返回 beacon contract 实例。

参数：

beacon - beacon 地址或 beacon contract 实例。
Contract - 一个 ethers contract factory 用作新的 implementation。
opts - 具有选项的对象：
- 常用选项中描述的其他选项。

始于：

@openzeppelin/hardhat-upgrades@1.13.0

deployBeaconProxy

async function deployBeaconProxy(
  beacon: string | ethers.Contract,
  attachTo: ethers.ContractFactory,
  args: unknown[] = [],
  opts?: {
    initializer?: string | false,
    txOverrides?: ethers.Overrides,
    useDefenderDeploy?: boolean,
    proxyFactory?: ethers.ContractFactory,
    deployFunction?: () => Promise<EthersOrDefenderDeployment>,
  },
): Promise<ethers.Contract>

给定一个现有的 beacon contract 地址和一个与 beacon 当前 implementation contract 对应的 ethers contract factory，创建一个 Beacon proxy，并返回一个具有 beacon proxy 地址和 implementation 接口的 contract 实例。如果设置了 args，将在代理部署期间使用提供的 args 调用 initializer 函数 initialize。

参数：

beacon - beacon 地址或 beacon contract 实例。
attachTo - 与 beacon 当前 implementation contract 对应的 ethers contract factory。
args - initializer 函数的参数。
opts - 具有选项的对象：
- initializer: 设置要调用的其他 initializer 函数（请参阅指定片段），或者指定 false 以禁用初始化。
- 常用选项中描述的其他选项。

返回值：

一个具有 beacon proxy 地址和 implementation 接口的 contract 实例。

始于：

@openzeppelin/hardhat-upgrades@1.13.0

forceImport

async function forceImport(
  address: string,
  deployedImpl: ethers.ContractFactory,
  opts?: {
    kind?: 'uups' | 'transparent' | 'beacon',
  },
): Promise<ethers.Contract>

强制导入现有的代理、信标或 implementation contract 部署，以便与此插件一起使用。提供现有代理、信标或 implementation 的地址，以及已部署的 implementation contract 的 ethers contract factory。

注意：导入代理或 beacon 时，deployedImpl 参数必须是正在使用的*当前* implementation contract 版本的 contract factory，而不是计划升级到的版本。

使用此函数通过导入先前的部署来重新创建丢失的网络文件，或者注册代理或 beacon 以进行升级，即使它们最初不是由此插件部署的。支持 UUPS、Transparent 和 Beacon proxies，以及 beacons 和 implementation contracts。

参数：

address - 现有代理、beacon 或 implementation 的地址。
deployedImpl - 已部署的 implementation contract 的 ethers contract factory。
opts - 具有选项的对象：
- kind: ("uups" | "transparent" | "beacon") 强制将代理视为 UUPS、Transparent 或 Beacon proxy。如果未提供，将自动检测代理类型。

返回值：

表示导入的代理、信标或 implementation 的 contract 实例。

始于

@openzeppelin/hardhat-upgrades@1.15.0

validateImplementation

async function validateImplementation(
  Contract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    kind?: 'uups' | 'transparent' | 'beacon',
  },
): Promise<void>

验证 implementation contract，而不部署它。

参数：

Contract - implementation contract 的 ethers contract factory。
opts - 具有选项的对象：
- 常用选项中描述的其他选项。

始于：

@openzeppelin/hardhat-upgrades@1.20.0

deployImplementation

async function deployImplementation(
  Contract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    constructorArgs?: unknown[],
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
    getTxResponse?: boolean,
    kind?: 'uups' | 'transparent' | 'beacon',
    useDefenderDeploy?: boolean,
  },
): Promise<string | ethers.providers.TransactionResponse>

验证并部署 implementation contract，并返回其地址。

参数：

Contract - 一个 ethers contract factory 用作 implementation。
opts - 具有选项的对象：
- getTxResponse: 如果设置为 true，则此函数会返回与新 implementation contract 的部署相对应的 ethers 交易响应，而不是其地址。请注意，如果新的 implementation contract 最初是由于 forceImport 导入的，则只会返回地址。
- 常用选项中描述的其他选项。

返回值：

对应其部署的地址，或 implementation contract 的 Ethers 交易响应

始于：

@openzeppelin/hardhat-upgrades@1.20.0

validateUpgrade

async function validateUpgrade(
  referenceAddressOrContract: string | ethers.ContractFactory,
  newContract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    unsafeAllowRenames?: boolean,
    unsafeSkipStorageCheck?: boolean,
    kind?: 'uups' | 'transparent' | 'beacon',
  },
): Promise<void>

验证新的 implementation contract，而不部署它，也不实际升级到它。将当前 implementation contract 与新的 implementation contract 进行比较，以检查存储布局兼容性错误。如果 referenceAddressOrContract 是当前 implementation 地址，则需要 kind 选项。

参数：

referenceAddressOrContract - 使用当前 implementation 的代理或 beacon 地址，或与当前 implementation 对应的地址或 ethers contract factory。
newContract - 新的 implementation contract。
opts - 具有选项的对象：
- 常用选项中描述的其他选项。

始于：

@openzeppelin/hardhat-upgrades@1.20.0

示例：

验证将现有代理升级到新 contract（将 PROXY_ADDRESS 替换为您的代理的地址）：

const { ethers, upgrades } = require('hardhat');

const BoxV2 = await ethers.getContractFactory('BoxV2');
await upgrades.validateUpgrade(PROXY_ADDRESS, BoxV2);

验证在两个 contract implementations 之间升级：

const { ethers, upgrades } = require('hardhat');

const Box = await ethers.getContractFactory('Box');
const BoxV2 = await ethers.getContractFactory('BoxV2');
await upgrades.validateUpgrade(Box, BoxV2);

prepareUpgrade

async function prepareUpgrade(
  referenceAddressOrContract: string | ethers.Contract,
  Contract: ethers.ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    unsafeAllowRenames?: boolean,
    unsafeSkipStorageCheck?: boolean,
    constructorArgs?: unknown[],
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    txOverrides?: ethers.Overrides,
    getTxResponse?: boolean,
    kind?: 'uups' | 'transparent' | 'beacon',
    useDefenderDeploy?: boolean,
  },
): Promise<string | ethers.providers.TransactionResponse>

验证并部署新的 implementation contract，并返回其地址。如果 referenceAddressOrContract 是当前 implementation 地址，则需要 kind 选项。使用此方法准备从您不直接控制或无法从 Hardhat 使用的管理地址运行的升级。

参数：

referenceAddressOrContract - 代理、beacon 或 implementation 地址或 contract 实例。
Contract - 新的 implementation contract。
opts - 具有选项的对象：
- getTxResponse: 如果设置为 true，则此函数会返回与新 implementation contract 的部署相对应的 ethers 交易响应，而不是其地址。请注意，如果新的 implementation contract 最初是由于 forceImport 导入的，则只会返回地址。
- 常用选项中描述的其他选项。

返回值：

对应其部署的地址，或 implementation contract 的 Ethers 交易响应

defender.deployContract

async function deployContract(
  Contract: ethers.ContractFactory,
  args: unknown[] = [],
  opts?: {
    unsafeAllowDeployContract?: boolean,
    pollingInterval?: number,
  },
): Promise<ethers.Contract>

使用 OpenZeppelin Defender 部署不可升级的 contract，并返回 contract 实例。如果 contract 看起来像 implementation contract，则会引发错误。

注意：不要使用此函数来部署可升级 contracts 的 implementations，因为此函数不执行升级安全验证。对于 implementation contracts，请改用 deployImplementation。

参数：

Contract - 一个 ethers contract factory 用作要部署的 contract。
opts - 具有选项的对象：
- unsafeAllowDeployContract: 如果设置为 true，即使 contract 看起来像 implementation contract，也允许部署 contract。默认为 false。
- pollingInterval: 在对结果 contract 实例调用 .waitForDeployment() 时，检查交易确认的轮询间隔（以毫秒为单位）。默认为 5000。

返回值：

contract 实例。

始于：

@openzeppelin/hardhat-upgrades@2.2.0

defender.getDeployApprovalProcess

async function getDeployApprovalProcess(
): Promise<{
    approvalProcessId: string,
    address?: string,
    viaType?: 'EOA' | 'Contract' | 'Multisig' | 'Safe' | 'Gnosis Multisig' | 'Relayer' | 'Unknown' | 'Timelock Controller' | 'ERC20' | 'Governor' | 'Fireblocks',
  }>

获取在 OpenZeppelin Defender 上为您的部署环境配置的默认部署审批流程。

返回值：

包含默认部署审批流程 ID 和关联地址的对象，例如中继器、EOA 或多重签名钱包地址。

始于：

@openzeppelin/hardhat-upgrades@2.5.0

defender.getUpgradeApprovalProcess

async function getUpgradeApprovalProcess(
): Promise<{
    approvalProcessId: string,
    address?: string,
    viaType?: 'EOA' | 'Contract' | 'Multisig' | 'Safe' | 'Gnosis Multisig' | 'Relayer' | 'Unknown' | 'Timelock Controller' | 'ERC20' | 'Governor' | 'Fireblocks',
  }>

获取在 OpenZeppelin Defender 上为您的部署环境配置的默认升级审批流程。例如，这对于确定可以在脚本中用作代理所有者的默认多重签名钱包非常有用。

返回值：

包含默认升级审批流程 ID 和关联地址的对象，例如多重签名或 Governor contract 地址。

始于：

@openzeppelin/hardhat-upgrades@2.5.0

defender.proposeUpgradeWithApproval

async function proposeUpgradeWithApproval(
  proxyAddress: string,
  ImplFactory: ContractFactory,
  opts?: {
    unsafeAllow?: ValidationError[],
    unsafeAllowRenames?: boolean,
    unsafeSkipStorageCheck?: boolean,
    constructorArgs?: unknown[],
    timeout?: number,
    pollingInterval?: number,
    redeployImplementation?: 'always' | 'never' | 'onchange',
    kind?: 'uups' | 'transparent' | 'beacon',
    useDefenderDeploy?: boolean,
    approvalProcessId?: string,
  },
): Promise<{
    proposalId: string,
    url: string,
    txResponse?: ethers.providers.TransactionResponse,
  }>

使用 OpenZeppelin Defender 上的升级审批流程提议升级。

类似于 prepareUpgrade。此方法验证并部署新的 implementation contract，但也使用 OpenZeppelin Defender 上的升级审批流程提议升级。支持 UUPS 或 Transparent proxies。当前不支持 beacon proxies 或 beacons。对于 beacons，请将 prepareUpgrade 和 Defender 上的交易提议一起使用，以将 beacon 升级到已部署的 implementation。

参数：

proxyAddress - 代理地址。
ImplFactory - 新的 implementation contract。
opts - 具有选项的对象：
- approvalProcessId: 升级审批流程的 ID。默认为在 Defender 上为您的部署环境配置的升级审批流程。
- 常用选项中描述的其他选项。

返回值：

包含 Defender 提议 ID、Safe App 中提议的 URL（如果适用）以及与新 implementation contract 部署对应的 ethers 交易响应的对象。请注意，如果新的 implementation contract 最初是由于 forceImport 导入的，则 ethers 交易响应将是不确定的。

始于：

@openzeppelin/hardhat-upgrades@2.2.0

admin.changeProxyAdmin

async function changeProxyAdmin(
  proxyAddress: string,
  newAdmin: string,
  signer?: ethers.Signer,
  opts?: {
    txOverrides?: ethers.Overrides,
  }
): Promise<void>

更改特定代理的管理员。

注意：OpenZeppelin Contracts 5.x 不支持此功能用于管理员或代理。

参数：

proxyAddress - 要更改的代理的地址。
newAdmin - 新的管理员地址。
signer - 用于交易的签名者。
opts - 具有选项的对象：
- 常用选项中描述的其他选项。

admin.transferProxyAdminOwnership

async function transferProxyAdminOwnership(
  proxyAddress: string,
  newOwner: string,
  signer?: ethers.Signer,
  opts?: {
    silent?: boolean,
    txOverrides?: ethers.Overrides,
  }
): Promise<void>

更改特定代理的代理管理合约的所有者。

注意：自`@openzeppelin/hardhat-upgrades@3.0.0`起，proxyAddress 参数是必需的

参数：

proxyAddress - 其管理所有权将被转移的代理的地址。
newOwner - 代理管理合约的新所有者地址。
signer - 用于交易的签名者。
opts - 具有选项的对象：
- silent: 如果设置为 true，则会静默有关受管理所有权转移影响的每个代理的控制台日志记录。
- 常用选项中描述的其他选项。

始于：

@openzeppelin/hardhat-upgrades@3.0.0

erc1967

async function erc1967.getImplementationAddress(proxyAddress: string): Promise<string>;
async function erc1967.getBeaconAddress(proxyAddress: string): Promise<string>;
async function erc1967.getAdminAddress(proxyAddress: string): Promise<string>;

此模块中的函数提供对代理合约的 ERC1967 变量的访问。

参数：

proxyAddress - 代理地址。

返回值：

根据调用的函数，返回 implementation、beacon 或管理地址。

beacon

async function beacon.getImplementationAddress(beaconAddress: string): Promise<string>;

此模块提供了一个便捷函数，用于从 beacon contract 获取 implementation 地址。

参数：

beaconAddress - beacon 地址。

返回值：

implementation 地址。

始于：

@openzeppelin/hardhat-upgrades@1.13.0

silenceWarnings

function silenceWarnings()

注意：此函数对于测试非常有用，但不建议在生产部署脚本中使用。

静默所有后续有关使用不安全标志的警告。在执行此操作之前，会打印最后一个警告。

verify

扩展 hardhat-verify 的 verify 任务以在 Etherscan 上完全验证代理。这支持验证由 Hardhat Upgrades 插件部署的代理 contracts。

参数与 hardhat-verify 的 verify 任务相同。如果提供的地址是代理，则此任务将验证代理的 implementation contract、代理本身以及任何与代理相关的 contracts，并在 Etherscan 上将代理链接到 implementation contract 的 ABI。如果提供的地址不是代理，则将改为在该地址上运行 hardhat-verify 中的常规 verify 任务。

当您在代理地址上运行此任务时，将验证以下 contracts：

你的 implementation contract
ERC1967Proxy 或 TransparentUpgradeableProxy 或 BeaconProxy（分别适用于 UUPS、transparent 或 beacon proxies）
ProxyAdmin（适用于 transparent proxies）
UpgradeableBeacon（适用于 beacon proxies）

始于：

@openzeppelin/hardhat-upgrades@2.0.0

用法：

要使用此任务，请确保已安装 hardhat-verify：

npm install --save-dev @nomicfoundation/hardhat-verify

然后，在您的 Hardhat 配置中导入 @nomicfoundation/hardhat-verify 插件以及 @openzeppelin/hardhat-upgrades 插件。例如，如果您使用的是 JavaScript，请在 hardhat.config.js 中导入插件：

require("@nomicfoundation/hardhat-verify");
require("@openzeppelin/hardhat-upgrades");

或者，如果您使用的是 TypeScript，请在 hardhat.config.ts 中导入插件：

import "@nomicfoundation/hardhat-verify";
import "@openzeppelin/hardhat-upgrades";

最后，按照 hardhat-verify 的用法文档配置您的 Etherscan API 密钥，并从命令行使用代理地址运行 verify 任务：

npx hardhat verify --network mainnet PROXY_ADDRESS

或使用 verify:verify 子任务以编程方式运行：

await hre.run("verify:verify", {
  address: PROXY_ADDRESS,
});

请注意，如果您的 implementation contract 仅使用 initializers，则无需在验证时包含构造函数参数。但是，如果您的 implementation contract 具有带有参数的实际构造函数（例如，为了设置 immutable 变量），则根据 task 或 subtask 的用法信息包括构造函数参数。