Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
pragma abicoder v2;

// OpenZeppelin v4
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

import { Delegator } from "./Delegator.sol";
import { Verifier, VerifyingKey } from "../logic/Verifier.sol";

/**
 * @title VKeySetter
 * @author Railgun Contributors
 * @notice
 */
contract VKeySetter is Ownable {
  Delegator public delegator;
  Verifier public verifier;

  // Lock adding new vKeys once this boolean is flipped
  enum VKeySetterState {
    SETTING,
    WAITING,
    COMMITTING
  }

  VKeySetterState public state;

  // Nullifiers => Commitments => Verification Key
  mapping(uint256 => mapping(uint256 => VerifyingKey)) private verificationKeys;

  // Owner can set vKeys in setting state
  // Owner can always change contract to waiting state
  // Governance is required to change state to committing state
  // Owner can only change contract to setting state when in committing state

  modifier onlySetting() {
    require(state == VKeySetterState.SETTING, "VKeySetter: Contract is not in setting state");
    _;
  }

  // modifier onlyWaiting() {
  //   require(state == VKeySetterState.WAITING, "VKeySetter: Contract is not in waiting state");
  //   _;
  // }

  modifier onlyCommitting() {
    require(state == VKeySetterState.COMMITTING, "VKeySetter: Contract is not in committing state");
    _;
  }

  modifier onlyDelegator() {
    require(msg.sender == address(delegator), "VKeySetter: Caller isn't governance");
    _;
  }

  /**
   * @notice Sets initial admin and delegator and verifier contract addresses
   */
  constructor(address _admin, Delegator _delegator, Verifier _verifier) {
    Ownable.transferOwnership(_admin);
    delegator = _delegator;
    verifier = _verifier;
  }

  /**
   * @notice Sets verification key
   * @param _nullifiers - number of nullifiers this verification key is for
   * @param _commitments - number of commitments out this verification key is for
   * @param _verifyingKey - verifyingKey to set
   */
  function setVerificationKey(
    uint256 _nullifiers,
    uint256 _commitments,
    VerifyingKey calldata _verifyingKey
  ) public onlyOwner onlySetting {
    verificationKeys[_nullifiers][_commitments] = _verifyingKey;
  }

  /**
   * @notice Gets verification key
   * @param _nullifiers - number of nullifiers this verification key is for
   * @param _commitments - number of commitments out this verification key is for
   */
  function getVerificationKey(
    uint256 _nullifiers,
    uint256 _commitments
  ) external view returns (VerifyingKey memory) {
    // Manually add getter so dynamic IC array is included in response
    return verificationKeys[_nullifiers][_commitments];
  }

  /**
   * @notice Sets verification key
   * @param _nullifiers - array of nullifier values of keys
   * @param _commitments - array of commitment values of keys
   * @param _verifyingKey - array of keys
   */
  function batchSetVerificationKey(
    uint256[] calldata _nullifiers,
    uint256[] calldata _commitments,
    VerifyingKey[] calldata _verifyingKey
  ) external {
    for (uint256 i = 0; i < _nullifiers.length; i += 1) {
      setVerificationKey(_nullifiers[i], _commitments[i], _verifyingKey[i]);
    }
  }

  /**
   * @notice Commits verification keys to contract
   * @param _nullifiers - number of nullifiers this verification key is for
   * @param _commitments - number of commitments out this verification key is for
   */
  function commitVerificationKey(
    uint256 _nullifiers,
    uint256 _commitments
  ) public onlyOwner onlyCommitting {
    // NOTE: The vkey configuration must EXACTLY match the desired vkey configuration on the verifier contract
    // Leaving a vkey empty on this contract can be used to delete a vkey on the verifier contract by setting
    // the values to 0

    delegator.callContract(
      address(verifier),
      abi.encodeWithSelector(
        Verifier.setVerificationKey.selector,
        _nullifiers,
        _commitments,
        verificationKeys[_nullifiers][_commitments]
      ),
      0
    );
  }

  /**
   * @notice Commits verification keys to contract as batch
   * @param _nullifiers - array of nullifier values of keys
   * @param _commitments - array of commitment values of keys
   */
  function batchCommitVerificationKey(
    uint256[] calldata _nullifiers,
    uint256[] calldata _commitments
  ) external {
    for (uint256 i = 0; i < _nullifiers.length; i += 1) {
      commitVerificationKey(_nullifiers[i], _commitments[i]);
    }
  }

  /**
   * @notice Set state to 'setting'
   */
  function stateToSetting() external onlyOwner onlyCommitting {
    state = VKeySetterState.SETTING;
  }

  /**
   * @notice Set state to 'waiting'
   */
  function stateToWaiting() external onlyOwner {
    state = VKeySetterState.WAITING;
  }

  /**
   * @notice Set state to 'committing'
   */
  function stateToCommitting() external onlyDelegator {
    state = VKeySetterState.COMMITTING;
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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 OwnableUpgradeable is Initializable, ContextUpgradeable {
    address private _owner;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @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 ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    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;
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @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 {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
pragma abicoder v2;

// OpenZeppelin v4
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";

/**
 * @title Delegator
 * @author Railgun Contributors
 * @notice 'Owner' contract for all railgun contracts
 * delegates permissions to other contracts (voter, role)
 */
contract Delegator is Ownable {
  /*
  Mapping structure is calling address => contract => function signature
  0 is used as a wildcard, so permission for contract 0 is permission for
  any contract, and permission for function signature 0 is permission for
  any function.

  Comments below use * to signify wildcard and . notation to separate address/contract/function.

  caller.*.* allows caller to call any function on any contract
  caller.X.* allows caller to call any function on contract X
  caller.*.Y allows caller to call function Y on any contract
  */
  mapping(address => mapping(address => mapping(bytes4 => bool))) public permissions;

  event GrantPermission(
    address indexed caller,
    address indexed contractAddress,
    bytes4 indexed selector
  );
  event RevokePermission(
    address indexed caller,
    address indexed contractAddress,
    bytes4 indexed selector
  );

  /**
   * @notice Sets initial admin
   */
  constructor(address _admin) {
    Ownable.transferOwnership(_admin);
  }

  /**
   * @notice Sets permission bit
   * @dev See comment on permissions mapping for wildcard format
   * @param _caller - caller to set permissions for
   * @param _contract - contract to set permissions for
   * @param _selector - selector to set permissions for
   * @param _permission - permission bit to set
   */
  function setPermission(
    address _caller,
    address _contract,
    bytes4 _selector,
    bool _permission
  ) public onlyOwner {
    // If permission set is different to new permission then we execute, otherwise skip
    if (permissions[_caller][_contract][_selector] != _permission) {
      // Set permission bit
      permissions[_caller][_contract][_selector] = _permission;

      // Emit event
      if (_permission) {
        emit GrantPermission(_caller, _contract, _selector);
      } else {
        emit RevokePermission(_caller, _contract, _selector);
      }
    }
  }

  /**
   * @notice Checks if caller has permission to execute function
   * @param _caller - caller to check permissions for
   * @param _contract - contract to check
   * @param _selector - function signature to check
   * @return if caller has permission
   */
  function checkPermission(
    address _caller,
    address _contract,
    bytes4 _selector
  ) public view returns (bool) {
    /* 
    See comment on permissions mapping for structure
    Comments below use * to signify wildcard and . notation to separate contract/function
    */
    return (_caller == Ownable.owner() ||
      permissions[_caller][_contract][_selector] || // Owner always has global permissions
      permissions[_caller][_contract][0x0] || // Permission for function is given
      permissions[_caller][address(0)][_selector] || // Permission for _contract.* is given
      permissions[_caller][address(0)][0x0]); // Global permission is given
  }

  /**
   * @notice Calls function
   * @dev calls to functions on this contract are intercepted and run directly
   * this is so the voting contract doesn't need to have special cases for calling
   * functions other than this one.
   * @param _contract - contract to call
   * @param _data - calldata to pass to contract
   * @return success - whether call succeeded
   * @return returnData - return data from function call
   */
  function callContract(
    address _contract,
    bytes calldata _data,
    uint256 _value
  ) public returns (bool success, bytes memory returnData) {
    // Get selector
    bytes4 selector = bytes4(_data);

    // Intercept calls to this contract
    if (_contract == address(this)) {
      if (selector == this.setPermission.selector) {
        // Decode call data
        (address caller, address calledContract, bytes4 _permissionSelector, bool permission) = abi
          .decode(abi.encodePacked(_data[4:]), (address, address, bytes4, bool));

        // Call setPermission
        setPermission(caller, calledContract, _permissionSelector, permission);

        // Return success with empty ReturnData bytes
        bytes memory empty;
        return (true, empty);
      } else if (selector == this.transferOwnership.selector) {
        // Decode call data
        address newOwner = abi.decode(abi.encodePacked(_data[4:]), (address));

        // Call transferOwnership
        Ownable.transferOwnership(newOwner);

        // Return success with empty ReturnData bytes
        bytes memory empty;
        return (true, empty);
      } else if (selector == this.renounceOwnership.selector) {
        // Call renounceOwnership
        Ownable.renounceOwnership();

        // Return success with empty ReturnData bytes
        bytes memory empty;
        return (true, empty);
      } else {
        // Return failed with empty ReturnData bytes
        bytes memory empty;
        return (false, empty);
      }
    }

    // Check permissions
    require(
      checkPermission(msg.sender, _contract, selector),
      "Delegator: Caller doesn't have permission"
    );

    // Call external contract and return
    // solhint-disable-next-line avoid-low-level-calls
    return _contract.call{ value: _value }(_data);
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
pragma abicoder v2;

// Constants
uint256 constant SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617;
// Verification bypass address, can't be address(0) as many burn prevention mechanisms will disallow transfers to 0
// Use 0x000000000000000000000000000000000000dEaD as an alternative known burn address
// https://etherscan.io/address/0x000000000000000000000000000000000000dEaD
address constant VERIFICATION_BYPASS = 0x000000000000000000000000000000000000dEaD;

bytes32 constant ACCEPT_RAILGUN_RESPONSE = keccak256(abi.encodePacked("Accept Railgun Session"));

struct ShieldRequest {
  CommitmentPreimage preimage;
  ShieldCiphertext ciphertext;
}

enum TokenType {
  ERC20,
  ERC721,
  ERC1155
}

struct TokenData {
  TokenType tokenType;
  address tokenAddress;
  uint256 tokenSubID;
}

struct CommitmentCiphertext {
  bytes32[4] ciphertext; // Ciphertext order: IV & tag (16 bytes each), encodedMPK (senderMPK XOR receiverMPK), random & amount (16 bytes each), token
  bytes32 blindedSenderViewingKey;
  bytes32 blindedReceiverViewingKey;
  bytes annotationData; // Only for sender to decrypt
  bytes memo; // Added to note ciphertext for decryption
}

struct ShieldCiphertext {
  bytes32[3] encryptedBundle; // IV shared (16 bytes), tag (16 bytes), random (16 bytes), IV sender (16 bytes), receiver viewing public key (32 bytes)
  bytes32 shieldKey; // Public key to generate shared key from
}

enum UnshieldType {
  NONE,
  NORMAL,
  REDIRECT
}

struct BoundParams {
  uint16 treeNumber;
  uint72 minGasPrice; // Only for type 0 transactions
  UnshieldType unshield;
  uint64 chainID;
  address adaptContract;
  bytes32 adaptParams;
  // For unshields do not include an element in ciphertext array
  // Ciphertext array length = commitments - unshields
  CommitmentCiphertext[] commitmentCiphertext;
}

struct Transaction {
  SnarkProof proof;
  bytes32 merkleRoot;
  bytes32[] nullifiers;
  bytes32[] commitments;
  BoundParams boundParams;
  CommitmentPreimage unshieldPreimage;
}

struct CommitmentPreimage {
  bytes32 npk; // Poseidon(Poseidon(spending public key, nullifying key), random)
  TokenData token; // Token field
  uint120 value; // Note value
}

struct G1Point {
  uint256 x;
  uint256 y;
}

// Encoding of field elements is: X[0] * z + X[1]
struct G2Point {
  uint256[2] x;
  uint256[2] y;
}

struct VerifyingKey {
  string artifactsIPFSHash;
  G1Point alpha1;
  G2Point beta2;
  G2Point gamma2;
  G2Point delta2;
  G1Point[] ic;
}

struct SnarkProof {
  G1Point a;
  G2Point b;
  G1Point c;
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
pragma abicoder v2;

import { G1Point, G2Point, VerifyingKey, SnarkProof, SNARK_SCALAR_FIELD } from "./Globals.sol";

library Snark {
  uint256 private constant PRIME_Q =
    21888242871839275222246405745257275088696311157297823662689037894645226208583;
  uint256 private constant PAIRING_INPUT_SIZE = 24;
  uint256 private constant PAIRING_INPUT_WIDTH = 768; // PAIRING_INPUT_SIZE * 32

  /**
   * @notice Computes the negation of point p
   * @dev The negation of p, i.e. p.plus(p.negate()) should be zero.
   * @return result
   */
  function negate(G1Point memory p) internal pure returns (G1Point memory) {
    if (p.x == 0 && p.y == 0) return G1Point(0, 0);

    // check for valid points y^2 = x^3 +3 % PRIME_Q
    uint256 rh = mulmod(p.x, p.x, PRIME_Q); //x^2
    rh = mulmod(rh, p.x, PRIME_Q); //x^3
    rh = addmod(rh, 3, PRIME_Q); //x^3 + 3
    uint256 lh = mulmod(p.y, p.y, PRIME_Q); //y^2
    require(lh == rh, "Snark: Invalid negation");

    return G1Point(p.x, PRIME_Q - (p.y % PRIME_Q));
  }

  /**
   * @notice Adds 2 G1 points
   * @return result
   */
  function add(G1Point memory p1, G1Point memory p2) internal view returns (G1Point memory) {
    // Format inputs
    uint256[4] memory input;
    input[0] = p1.x;
    input[1] = p1.y;
    input[2] = p2.x;
    input[3] = p2.y;

    // Setup output variables
    bool success;
    G1Point memory result;

    // Add points
    // solhint-disable-next-line no-inline-assembly
    assembly {
      success := staticcall(sub(gas(), 2000), 6, input, 0x80, result, 0x40)
    }

    // Check if operation succeeded
    require(success, "Snark: Add Failed");

    return result;
  }

  /**
   * @notice Scalar multiplies two G1 points p, s
   * @dev The product of a point on G1 and a scalar, i.e.
   * p == p.scalar_mul(1) and p.plus(p) == p.scalar_mul(2) for all
   * points p.
   * @return r - result
   */
  function scalarMul(G1Point memory p, uint256 s) internal view returns (G1Point memory r) {
    uint256[3] memory input;
    input[0] = p.x;
    input[1] = p.y;
    input[2] = s;
    bool success;

    // solhint-disable-next-line no-inline-assembly
    assembly {
      success := staticcall(sub(gas(), 2000), 7, input, 0x60, r, 0x40)
    }

    // Check multiplication succeeded
    require(success, "Snark: Scalar Multiplication Failed");
  }

  /**
   * @notice Performs pairing check on points
   * @dev The result of computing the pairing check
   * e(p1[0], p2[0]) *  .... * e(p1[n], p2[n]) == 1
   * For example,
   * pairing([P1(), P1().negate()], [P2(), P2()]) should return true.
   * @return if pairing check passed
   */
  function pairing(
    G1Point memory _a1,
    G2Point memory _a2,
    G1Point memory _b1,
    G2Point memory _b2,
    G1Point memory _c1,
    G2Point memory _c2,
    G1Point memory _d1,
    G2Point memory _d2
  ) internal view returns (bool) {
    uint256[PAIRING_INPUT_SIZE] memory input = [
      _a1.x,
      _a1.y,
      _a2.x[0],
      _a2.x[1],
      _a2.y[0],
      _a2.y[1],
      _b1.x,
      _b1.y,
      _b2.x[0],
      _b2.x[1],
      _b2.y[0],
      _b2.y[1],
      _c1.x,
      _c1.y,
      _c2.x[0],
      _c2.x[1],
      _c2.y[0],
      _c2.y[1],
      _d1.x,
      _d1.y,
      _d2.x[0],
      _d2.x[1],
      _d2.y[0],
      _d2.y[1]
    ];

    uint256[1] memory out;
    bool success;

    // solhint-disable-next-line no-inline-assembly
    assembly {
      success := staticcall(sub(gas(), 2000), 8, input, PAIRING_INPUT_WIDTH, out, 0x20)
    }

    // Check if operation succeeded
    require(success, "Snark: Pairing Verification Failed");

    return out[0] != 0;
  }

  /**
   * @notice Verifies snark proof against proving key
   * @param _vk - Verification Key
   * @param _proof - snark proof
   * @param _inputs - inputs
   */
  function verify(
    VerifyingKey memory _vk,
    SnarkProof memory _proof,
    uint256[] memory _inputs
  ) internal view returns (bool) {
    // Compute the linear combination vkX
    G1Point memory vkX = G1Point(0, 0);

    // Loop through every input
    for (uint256 i = 0; i < _inputs.length; i += 1) {
      // Make sure inputs are less than SNARK_SCALAR_FIELD
      require(_inputs[i] < SNARK_SCALAR_FIELD, "Snark: Input > SNARK_SCALAR_FIELD");

      // Add to vkX point
      vkX = add(vkX, scalarMul(_vk.ic[i + 1], _inputs[i]));
    }

    // Compute final vkX point
    vkX = add(vkX, _vk.ic[0]);

    // Verify pairing and return
    return
      pairing(
        negate(_proof.a),
        _proof.b,
        _vk.alpha1,
        _vk.beta2,
        vkX,
        _vk.gamma2,
        _proof.c,
        _vk.delta2
      );
  }
}

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
pragma abicoder v2;

// OpenZeppelin v4
import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

import { VERIFICATION_BYPASS, SnarkProof, Transaction, BoundParams, VerifyingKey, SNARK_SCALAR_FIELD } from "./Globals.sol";

import { Snark } from "./Snark.sol";

/**
 * @title Verifier
 * @author Railgun Contributors
 * @notice Verifies snark proof
 * @dev Functions in this contract statelessly verify proofs, nullifiers and adaptID should be checked in RailgunLogic.
 */
contract Verifier is OwnableUpgradeable {
  // NOTE: The order of instantiation MUST stay the same across upgrades
  // add new variables to the bottom of the list and decrement __gap
  // See https://docs.openzeppelin.com/learn/upgrading-smart-contracts#upgrading

  // Verifying key set event
  event VerifyingKeySet(uint256 nullifiers, uint256 commitments, VerifyingKey verifyingKey);

  // Nullifiers => Commitments => Verification Key
  mapping(uint256 => mapping(uint256 => VerifyingKey)) private verificationKeys;

  /**
   * @notice Sets verification key
   * @param _nullifiers - number of nullifiers this verification key is for
   * @param _commitments - number of commitments out this verification key is for
   * @param _verifyingKey - verifyingKey to set
   */
  function setVerificationKey(
    uint256 _nullifiers,
    uint256 _commitments,
    VerifyingKey calldata _verifyingKey
  ) public onlyOwner {
    verificationKeys[_nullifiers][_commitments] = _verifyingKey;

    emit VerifyingKeySet(_nullifiers, _commitments, _verifyingKey);
  }

  /**
   * @notice Gets verification key
   * @param _nullifiers - number of nullifiers this verification key is for
   * @param _commitments - number of commitments out this verification key is for
   */
  function getVerificationKey(
    uint256 _nullifiers,
    uint256 _commitments
  ) public view returns (VerifyingKey memory) {
    // Manually add getter so dynamic IC array is included in response
    return verificationKeys[_nullifiers][_commitments];
  }

  /**
   * @notice Calculates hash of transaction bound params for snark verification
   * @param _boundParams - bound parameters
   * @return bound parameters hash
   */
  function hashBoundParams(BoundParams calldata _boundParams) public pure returns (uint256) {
    return uint256(keccak256(abi.encode(_boundParams))) % SNARK_SCALAR_FIELD;
  }

  /**
   * @notice Verifies inputs against a verification key
   * @param _verifyingKey - verifying key to verify with
   * @param _proof - proof to verify
   * @param _inputs - input to verify
   * @return proof validity
   */
  function verifyProof(
    VerifyingKey memory _verifyingKey,
    SnarkProof calldata _proof,
    uint256[] memory _inputs
  ) public view returns (bool) {
    return Snark.verify(_verifyingKey, _proof, _inputs);
  }

  /**
   * @notice Verifies a transaction
   * @param _transaction to verify
   * @return transaction validity
   */
  function verify(Transaction calldata _transaction) public view returns (bool) {
    uint256 nullifiersLength = _transaction.nullifiers.length;
    uint256 commitmentsLength = _transaction.commitments.length;

    // Retrieve verification key
    VerifyingKey memory verifyingKey = verificationKeys[nullifiersLength][commitmentsLength];

    // Check if verifying key is set
    require(verifyingKey.alpha1.x != 0, "Verifier: Key not set");

    // Calculate inputs
    uint256[] memory inputs = new uint256[](2 + nullifiersLength + commitmentsLength);
    inputs[0] = uint256(_transaction.merkleRoot);

    // Hash bound parameters
    inputs[1] = hashBoundParams(_transaction.boundParams);

    // Loop through nullifiers and add to inputs
    for (uint256 i = 0; i < nullifiersLength; i += 1) {
      inputs[2 + i] = uint256(_transaction.nullifiers[i]);
    }

    // Loop through commitments and add to inputs
    for (uint256 i = 0; i < commitmentsLength; i += 1) {
      inputs[2 + nullifiersLength + i] = uint256(_transaction.commitments[i]);
    }

    // Verify snark proof
    bool validity = verifyProof(verifyingKey, _transaction.proof, inputs);

    // Always return true in gas estimation transaction
    // This is so relayer fees can be calculated without needing to compute a proof
    // solhint-disable-next-line avoid-tx-origin
    if (tx.origin == VERIFICATION_BYPASS) {
      return true;
    } else {
      return validity;
    }
  }

  uint256[49] private __gap;
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_admin","type":"address"},{"internalType":"contract Delegator","name":"_delegator","type":"address"},{"internalType":"contract Verifier","name":"_verifier","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"_nullifiers","type":"uint256[]"},{"internalType":"uint256[]","name":"_commitments","type":"uint256[]"}],"name":"batchCommitVerificationKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_nullifiers","type":"uint256[]"},{"internalType":"uint256[]","name":"_commitments","type":"uint256[]"},{"components":[{"internalType":"string","name":"artifactsIPFSHash","type":"string"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point","name":"alpha1","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"beta2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"gamma2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"delta2","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point[]","name":"ic","type":"tuple[]"}],"internalType":"struct VerifyingKey[]","name":"_verifyingKey","type":"tuple[]"}],"name":"batchSetVerificationKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nullifiers","type":"uint256"},{"internalType":"uint256","name":"_commitments","type":"uint256"}],"name":"commitVerificationKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"delegator","outputs":[{"internalType":"contract Delegator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nullifiers","type":"uint256"},{"internalType":"uint256","name":"_commitments","type":"uint256"}],"name":"getVerificationKey","outputs":[{"components":[{"internalType":"string","name":"artifactsIPFSHash","type":"string"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point","name":"alpha1","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"beta2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"gamma2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"delta2","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point[]","name":"ic","type":"tuple[]"}],"internalType":"struct VerifyingKey","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_nullifiers","type":"uint256"},{"internalType":"uint256","name":"_commitments","type":"uint256"},{"components":[{"internalType":"string","name":"artifactsIPFSHash","type":"string"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point","name":"alpha1","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"beta2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"gamma2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"x","type":"uint256[2]"},{"internalType":"uint256[2]","name":"y","type":"uint256[2]"}],"internalType":"struct G2Point","name":"delta2","type":"tuple"},{"components":[{"internalType":"uint256","name":"x","type":"uint256"},{"internalType":"uint256","name":"y","type":"uint256"}],"internalType":"struct G1Point[]","name":"ic","type":"tuple[]"}],"internalType":"struct VerifyingKey","name":"_verifyingKey","type":"tuple"}],"name":"setVerificationKey","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"state","outputs":[{"internalType":"enum VKeySetter.VKeySetterState","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stateToCommitting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stateToSetting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stateToWaiting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"verifier","outputs":[{"internalType":"contract Verifier","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000bbc2fb58643235affbf1f0cdd27bc6e6cfbba4e2000000000000000000000000b6d513f6222ee92fff975e901bd792e2513fb53b000000000000000000000000fa7093cdd9ee6932b4eb2c9e1cde7ce00b1fa4b9

-----Decoded View---------------
Arg [0] : _admin (address): 0xbbc2fB58643235AFfBF1f0CDd27Bc6E6CFBBa4e2
Arg [1] : _delegator (address): 0xB6d513f6222Ee92Fff975E901bd792E2513fB53B
Arg [2] : _verifier (address): 0xFA7093CDD9EE6932B4eb2c9e1cde7CE00B1FA4b9

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000bbc2fb58643235affbf1f0cdd27bc6e6cfbba4e2
Arg [1] : 000000000000000000000000b6d513f6222ee92fff975e901bd792e2513fb53b
Arg [2] : 000000000000000000000000fa7093cdd9ee6932b4eb2c9e1cde7ce00b1fa4b9