Contract Address Details

//SPDX-License-Identifier: MIT

import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { Bytes32ArrayUtils } from "../external/Bytes32ArrayUtils.sol";
import { IPaymentVerifierRegistry } from "../interfaces/IPaymentVerifierRegistry.sol";

pragma solidity ^0.8.18;

contract PaymentVerifierRegistry is Ownable, IPaymentVerifierRegistry {

    using Bytes32ArrayUtils for bytes32[];

    /* ============ Structs ============ */

    struct PaymentMethodConfig {
        bool initialized;
        address verifier;
        mapping(bytes32 => bool) isCurrency;
        bytes32[] currencies;
    }
    
    /* ============ Events ============ */

    event PaymentMethodAdded(bytes32 indexed paymentMethod);
    event PaymentMethodRemoved(bytes32 indexed paymentMethod);
    event CurrencyAdded(bytes32 indexed paymentMethod, bytes32 indexed currencyCode);
    event CurrencyRemoved(bytes32 indexed paymentMethod, bytes32 indexed currencyCode);

    /* ============ State Variables ============ */
    mapping(bytes32 => PaymentMethodConfig) public store;
    bytes32[] public paymentMethods;

    /* ============ Constructor ============ */
    constructor() Ownable() {}
    
    /* ============ External Functions ============ */

    /**
     * Adds a new payment method with processors and currencies
     * @param _paymentMethod The payment method hash; Hash the payment method name in lowercase
     * @param _verifier The verifier address to add for this payment method
     * @param _currencies Array of currency code hashes to support
     */
    function addPaymentMethod(
        bytes32 _paymentMethod,
        address _verifier,
        bytes32[] calldata _currencies
    ) external onlyOwner {
        require(!store[_paymentMethod].initialized, "Payment method already exists");
        require(_verifier != address(0), "Invalid verifier");
        require(_currencies.length > 0, "Invalid currencies length");
        
        store[_paymentMethod].initialized = true;
        store[_paymentMethod].verifier = _verifier;
        
        addCurrencies(_paymentMethod, _currencies);

        paymentMethods.push(_paymentMethod);
        
        emit PaymentMethodAdded(_paymentMethod);
    }
    
    /**
     * Removes a payment method and associated configuration
     * @param _paymentMethod The payment method to remove
     * @dev Only callable by owner
     */
    function removePaymentMethod(bytes32 _paymentMethod) external onlyOwner {
        require(store[_paymentMethod].initialized, "Payment method does not exist");
        
        bytes32[] memory currencies = store[_paymentMethod].currencies;
        for (uint256 i = 0; i < currencies.length; i++) {
            _removeCurrency(_paymentMethod, currencies[i]);
        }
        
        delete store[_paymentMethod];
        
        paymentMethods.removeStorage(_paymentMethod);
        
        emit PaymentMethodRemoved(_paymentMethod);
    }

    /**
     * Adds supported currencies for a specific payment method
     * @param _paymentMethod The payment method hash
     * @param _currencies Array of currency code hashes (e.g., keccak256("USD"), keccak256("EUR"))
     */
    function addCurrencies(bytes32 _paymentMethod, bytes32[] calldata _currencies) public onlyOwner {
        require(store[_paymentMethod].initialized, "Payment method does not exist");
        require(_currencies.length > 0, "Invalid currencies length");
        
        for (uint256 i = 0; i < _currencies.length; i++) {
            _addCurrency(_paymentMethod, _currencies[i]);
        }
    }
    
    /**
     * Removes supported currencies for a specific payment method
     * @param _paymentMethod The payment method hash
     * @param _currencies Array of currency code hashes to remove
     */
    function removeCurrencies(bytes32 _paymentMethod, bytes32[] calldata _currencies) external onlyOwner {
        require(_currencies.length > 0, "Invalid currencies length");
        
        for (uint256 i = 0; i < _currencies.length; i++) {
            _removeCurrency(_paymentMethod, _currencies[i]);
        }
    }

    /* ============ External View Functions ============ */
    
    function isPaymentMethod(bytes32 _paymentMethod) external view returns (bool) {
        return store[_paymentMethod].initialized;
    }

    function getPaymentMethods() external view returns (bytes32[] memory) {
        return paymentMethods;
    }
    
    function getVerifier(bytes32 _paymentMethod) external view returns (address) {
        return store[_paymentMethod].verifier;
    }

    function isCurrency(bytes32 _paymentMethod, bytes32 _currencyCode) external view returns (bool) {
        return store[_paymentMethod].isCurrency[_currencyCode];
    }
    
    function getCurrencies(bytes32 _paymentMethod) external view returns (bytes32[] memory) {
        return store[_paymentMethod].currencies;
    }

    /* ============ Internal Functions ============ */

    function _addCurrency(bytes32 _paymentMethod, bytes32 _currencyCode) internal {
        require(_currencyCode != bytes32(0), "Invalid currency code");
        require(!store[_paymentMethod].isCurrency[_currencyCode], "Currency already exists");

        store[_paymentMethod].isCurrency[_currencyCode] = true;
        store[_paymentMethod].currencies.push(_currencyCode);
        emit CurrencyAdded(_paymentMethod, _currencyCode);
    }
    
    function _removeCurrency(bytes32 _paymentMethod, bytes32 _currencyCode) internal {
        require(store[_paymentMethod].isCurrency[_currencyCode], "Currency does not exist");

        store[_paymentMethod].isCurrency[_currencyCode] = false;
        store[_paymentMethod].currencies.removeStorage(_currencyCode);
        emit CurrencyRemoved(_paymentMethod, _currencyCode);
    }
} 
        

// 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 v4.4.1 (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;
    }
}
          

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.17;

/**
 * @title Bytes32ArrayUtils
 * @author ZKP2P
 *
 * Fork of Set Protocol's AddressArrayUtils library adapted for usage with bytes32 arrays.
 */
library Bytes32ArrayUtils {

    uint256 constant internal MAX_INT = 2**256 - 1;

    /**
     * Finds the index of the first occurrence of the given element.
     * @param A The input array to search
     * @param a The value to find
     * @return Returns (index and isIn) for the first occurrence starting from index 0
     */
    function indexOf(bytes32[] memory A, bytes32 a) internal pure returns (uint256, bool) {
        uint256 length = A.length;
        for (uint256 i = 0; i < length; i++) {
            if (A[i] == a) {
                return (i, true);
            }
        }
        return (MAX_INT, false);
    }

    /**
    * Returns true if the value is present in the list. Uses indexOf internally.
    * @param A The input array to search
    * @param a The value to find
    * @return Returns isIn for the first occurrence starting from index 0
    */
    function contains(bytes32[] memory A, bytes32 a) internal pure returns (bool) {
        (, bool isIn) = indexOf(A, a);
        return isIn;
    }

    /**
    * Returns true if there are 2 elements that are the same in an array
    * @param A The input array to search
    * @return Returns boolean for the first occurrence of a duplicate
    */
    function hasDuplicate(bytes32[] memory A) internal pure returns(bool) {
        require(A.length > 0, "A is empty");

        for (uint256 i = 0; i < A.length - 1; i++) {
            bytes32 current = A[i];
            for (uint256 j = i + 1; j < A.length; j++) {
                if (current == A[j]) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * @param A The input array to search
     * @param a The bytes32 to remove
     * @return Returns the array with the object removed.
     */
    function remove(bytes32[] memory A, bytes32 a)
        internal
        pure
        returns (bytes32[] memory)
    {
        (uint256 index, bool isIn) = indexOf(A, a);
        if (!isIn) {
            revert("bytes32 not in array.");
        } else {
            (bytes32[] memory _A,) = pop(A, index);
            return _A;
        }
    }

    /**
     * @param A The input array to search
     * @param a The bytes32 to remove
     */
    function removeStorage(bytes32[] storage A, bytes32 a)
        internal
    {
        (uint256 index, bool isIn) = indexOf(A, a);
        if (!isIn) {
            revert("bytes32 not in array.");
        } else {
            uint256 lastIndex = A.length - 1; // If the array would be empty, the previous line would throw, so no underflow here
            if (index != lastIndex) { A[index] = A[lastIndex]; }
            A.pop();
        }
    }

    /**
    * Removes specified index from array
    * @param A The input array to search
    * @param index The index to remove
    * @return Returns the new array and the removed entry
    */
    function pop(bytes32[] memory A, uint256 index)
        internal
        pure
        returns (bytes32[] memory, bytes32)
    {
        uint256 length = A.length;
        require(index < A.length, "Index must be < A length");
        bytes32[] memory newBytes = new bytes32[](length - 1);
        for (uint256 i = 0; i < index; i++) {
            newBytes[i] = A[i];
        }
        for (uint256 j = index + 1; j < length; j++) {
            newBytes[j - 1] = A[j];
        }
        return (newBytes, A[index]);
    }
}
          

//SPDX-License-Identifier: MIT

pragma solidity ^0.8.18;

interface IPaymentVerifierRegistry {
    function isPaymentMethod(bytes32 _paymentMethod) external view returns (bool);
    function getPaymentMethods() external view returns (bytes32[] memory);
    function getVerifier(bytes32 _paymentMethod) external view returns (address);
    function isCurrency(bytes32 _paymentMethod, bytes32 _currencyCode) external view returns (bool);
    function getCurrencies(bytes32 _paymentMethod) external view returns (bytes32[] memory);
}