{"sources":{"StablecoinProxy.sol":{"content":"// Sources flattened with hardhat v2.22.8 https://hardhat.org\r\n\r\n// SPDX-License-Identifier: MIT\r\n\r\n// File @openzeppelin/contracts/proxy/beacon/IBeacon.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/beacon/IBeacon.sol)\r\n\r\npragma solidity ^0.8.20;\r\n\r\n/**\r\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\r\n */\r\ninterface IBeacon {\r\n    /**\r\n     * @dev Must return an address that can be used as a delegate call target.\r\n     *\r\n     * {UpgradeableBeacon} will check that this address is a contract.\r\n     */\r\n    function implementation() external view returns (address);\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/utils/Address.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)\r\n\r\npragma solidity ^0.8.20;\r\n\r\n/**\r\n * @dev Collection of functions related to the address type\r\n */\r\nlibrary Address {\r\n    /**\r\n     * @dev The ETH balance of the account is not enough to perform the operation.\r\n     */\r\n    error AddressInsufficientBalance(address account);\r\n\r\n    /**\r\n     * @dev There's no code at `target` (it is not a contract).\r\n     */\r\n    error AddressEmptyCode(address target);\r\n\r\n    /**\r\n     * @dev A call to an address target failed. The target may have reverted.\r\n     */\r\n    error FailedInnerCall();\r\n\r\n    /**\r\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\r\n     * `recipient`, forwarding all available gas and reverting on errors.\r\n     *\r\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\r\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\r\n     * imposed by `transfer`, making them unable to receive funds via\r\n     * `transfer`. {sendValue} removes this limitation.\r\n     *\r\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\r\n     *\r\n     * IMPORTANT: because control is transferred to `recipient`, care must be\r\n     * taken to not create reentrancy vulnerabilities. Consider using\r\n     * {ReentrancyGuard} or the\r\n     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\r\n     */\r\n    function sendValue(address payable recipient, uint256 amount) internal {\r\n        if (address(this).balance < amount) {\r\n            revert AddressInsufficientBalance(address(this));\r\n        }\r\n\r\n        (bool success, ) = recipient.call{value: amount}(\"\");\r\n        if (!success) {\r\n            revert FailedInnerCall();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Performs a Solidity function call using a low level `call`. A\r\n     * plain `call` is an unsafe replacement for a function call: use this\r\n     * function instead.\r\n     *\r\n     * If `target` reverts with a revert reason or custom error, it is bubbled\r\n     * up by this function (like regular Solidity function calls). However, if\r\n     * the call reverted with no returned reason, this function reverts with a\r\n     * {FailedInnerCall} error.\r\n     *\r\n     * Returns the raw returned data. To convert to the expected return value,\r\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - `target` must be a contract.\r\n     * - calling `target` with `data` must not revert.\r\n     */\r\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        return functionCallWithValue(target, data, 0);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but also transferring `value` wei to `target`.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - the calling contract must have an ETH balance of at least `value`.\r\n     * - the called Solidity function must be `payable`.\r\n     */\r\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\r\n        if (address(this).balance < value) {\r\n            revert AddressInsufficientBalance(address(this));\r\n        }\r\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\r\n        return verifyCallResultFromTarget(target, success, returndata);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a static call.\r\n     */\r\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\r\n        (bool success, bytes memory returndata) = target.staticcall(data);\r\n        return verifyCallResultFromTarget(target, success, returndata);\r\n    }\r\n\r\n    /**\r\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\r\n     * but performing a delegate call.\r\n     */\r\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\r\n        (bool success, bytes memory returndata) = target.delegatecall(data);\r\n        return verifyCallResultFromTarget(target, success, returndata);\r\n    }\r\n\r\n    /**\r\n     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target\r\n     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an\r\n     * unsuccessful call.\r\n     */\r\n    function verifyCallResultFromTarget(\r\n        address target,\r\n        bool success,\r\n        bytes memory returndata\r\n    ) internal view returns (bytes memory) {\r\n        if (!success) {\r\n            _revert(returndata);\r\n        } else {\r\n            // only check if target is a contract if the call was successful and the return data is empty\r\n            // otherwise we already know that it was a contract\r\n            if (returndata.length == 0 && target.code.length == 0) {\r\n                revert AddressEmptyCode(target);\r\n            }\r\n            return returndata;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the\r\n     * revert reason or with a default {FailedInnerCall} error.\r\n     */\r\n    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {\r\n        if (!success) {\r\n            _revert(returndata);\r\n        } else {\r\n            return returndata;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.\r\n     */\r\n    function _revert(bytes memory returndata) private pure {\r\n        // Look for revert reason and bubble it up if present\r\n        if (returndata.length > 0) {\r\n            // The easiest way to bubble the revert reason is using memory via assembly\r\n            /// @solidity memory-safe-assembly\r\n            assembly {\r\n                let returndata_size := mload(returndata)\r\n                revert(add(32, returndata), returndata_size)\r\n            }\r\n        } else {\r\n            revert FailedInnerCall();\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/utils/StorageSlot.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)\r\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\r\n\r\npragma solidity ^0.8.20;\r\n\r\n/**\r\n * @dev Library for reading and writing primitive types to specific storage slots.\r\n *\r\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\r\n * This library helps with reading and writing to such slots without the need for inline assembly.\r\n *\r\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\r\n *\r\n * Example usage to set ERC1967 implementation slot:\r\n * ```solidity\r\n * contract ERC1967 {\r\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\r\n *\r\n *     function _getImplementation() internal view returns (address) {\r\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\r\n *     }\r\n *\r\n *     function _setImplementation(address newImplementation) internal {\r\n *         require(newImplementation.code.length > 0);\r\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\r\n *     }\r\n * }\r\n * ```\r\n */\r\nlibrary StorageSlot {\r\n    struct AddressSlot {\r\n        address value;\r\n    }\r\n\r\n    struct BooleanSlot {\r\n        bool value;\r\n    }\r\n\r\n    struct Bytes32Slot {\r\n        bytes32 value;\r\n    }\r\n\r\n    struct Uint256Slot {\r\n        uint256 value;\r\n    }\r\n\r\n    struct StringSlot {\r\n        string value;\r\n    }\r\n\r\n    struct BytesSlot {\r\n        bytes value;\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\r\n     */\r\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\r\n     */\r\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\r\n     */\r\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\r\n     */\r\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\r\n     */\r\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\r\n     */\r\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := store.slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\r\n     */\r\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := slot\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\r\n     */\r\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\r\n        /// @solidity memory-safe-assembly\r\n        assembly {\r\n            r.slot := store.slot\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/proxy/ERC1967/ERC1967Utils.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Utils.sol)\r\n\r\npragma solidity ^0.8.20;\r\n\r\n\r\n\r\n/**\r\n * @dev This abstract contract provides getters and event emitting update functions for\r\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\r\n */\r\nlibrary ERC1967Utils {\r\n    // We re-declare ERC-1967 events here because they can't be used directly from IERC1967.\r\n    // This will be fixed in Solidity 0.8.21. At that point we should remove these events.\r\n    /**\r\n     * @dev Emitted when the implementation is upgraded.\r\n     */\r\n    event Upgraded(address indexed implementation);\r\n\r\n    /**\r\n     * @dev Emitted when the admin account has changed.\r\n     */\r\n    event AdminChanged(address previousAdmin, address newAdmin);\r\n\r\n    /**\r\n     * @dev Emitted when the beacon is changed.\r\n     */\r\n    event BeaconUpgraded(address indexed beacon);\r\n\r\n    /**\r\n     * @dev Storage slot with the address of the current implementation.\r\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1.\r\n     */\r\n    // solhint-disable-next-line private-vars-leading-underscore\r\n    bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\r\n\r\n    /**\r\n     * @dev The `implementation` of the proxy is invalid.\r\n     */\r\n    error ERC1967InvalidImplementation(address implementation);\r\n\r\n    /**\r\n     * @dev The `admin` of the proxy is invalid.\r\n     */\r\n    error ERC1967InvalidAdmin(address admin);\r\n\r\n    /**\r\n     * @dev The `beacon` of the proxy is invalid.\r\n     */\r\n    error ERC1967InvalidBeacon(address beacon);\r\n\r\n    /**\r\n     * @dev An upgrade function sees `msg.value > 0` that may be lost.\r\n     */\r\n    error ERC1967NonPayable();\r\n\r\n    /**\r\n     * @dev Returns the current implementation address.\r\n     */\r\n    function getImplementation() internal view returns (address) {\r\n        return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;\r\n    }\r\n\r\n    /**\r\n     * @dev Stores a new address in the EIP1967 implementation slot.\r\n     */\r\n    function _setImplementation(address newImplementation) private {\r\n        if (newImplementation.code.length == 0) {\r\n            revert ERC1967InvalidImplementation(newImplementation);\r\n        }\r\n        StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;\r\n    }\r\n\r\n    /**\r\n     * @dev Performs implementation upgrade with additional setup call if data is nonempty.\r\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\r\n     * to avoid stuck value in the contract.\r\n     *\r\n     * Emits an {IERC1967-Upgraded} event.\r\n     */\r\n    function upgradeToAndCall(address newImplementation, bytes memory data) internal {\r\n        _setImplementation(newImplementation);\r\n        emit Upgraded(newImplementation);\r\n\r\n        if (data.length > 0) {\r\n            Address.functionDelegateCall(newImplementation, data);\r\n        } else {\r\n            _checkNonPayable();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Storage slot with the admin of the contract.\r\n     * This is the keccak-256 hash of \"eip1967.proxy.admin\" subtracted by 1.\r\n     */\r\n    // solhint-disable-next-line private-vars-leading-underscore\r\n    bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\r\n\r\n    /**\r\n     * @dev Returns the current admin.\r\n     *\r\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\r\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\r\n     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\r\n     */\r\n    function getAdmin() internal view returns (address) {\r\n        return StorageSlot.getAddressSlot(ADMIN_SLOT).value;\r\n    }\r\n\r\n    /**\r\n     * @dev Stores a new address in the EIP1967 admin slot.\r\n     */\r\n    function _setAdmin(address newAdmin) private {\r\n        if (newAdmin == address(0)) {\r\n            revert ERC1967InvalidAdmin(address(0));\r\n        }\r\n        StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;\r\n    }\r\n\r\n    /**\r\n     * @dev Changes the admin of the proxy.\r\n     *\r\n     * Emits an {IERC1967-AdminChanged} event.\r\n     */\r\n    function changeAdmin(address newAdmin) internal {\r\n        emit AdminChanged(getAdmin(), newAdmin);\r\n        _setAdmin(newAdmin);\r\n    }\r\n\r\n    /**\r\n     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\r\n     * This is the keccak-256 hash of \"eip1967.proxy.beacon\" subtracted by 1.\r\n     */\r\n    // solhint-disable-next-line private-vars-leading-underscore\r\n    bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\r\n\r\n    /**\r\n     * @dev Returns the current beacon.\r\n     */\r\n    function getBeacon() internal view returns (address) {\r\n        return StorageSlot.getAddressSlot(BEACON_SLOT).value;\r\n    }\r\n\r\n    /**\r\n     * @dev Stores a new beacon in the EIP1967 beacon slot.\r\n     */\r\n    function _setBeacon(address newBeacon) private {\r\n        if (newBeacon.code.length == 0) {\r\n            revert ERC1967InvalidBeacon(newBeacon);\r\n        }\r\n\r\n        StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;\r\n\r\n        address beaconImplementation = IBeacon(newBeacon).implementation();\r\n        if (beaconImplementation.code.length == 0) {\r\n            revert ERC1967InvalidImplementation(beaconImplementation);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Change the beacon and trigger a setup call if data is nonempty.\r\n     * This function is payable only if the setup call is performed, otherwise `msg.value` is rejected\r\n     * to avoid stuck value in the contract.\r\n     *\r\n     * Emits an {IERC1967-BeaconUpgraded} event.\r\n     *\r\n     * CAUTION: Invoking this function has no effect on an instance of {BeaconProxy} since v5, since\r\n     * it uses an immutable beacon without looking at the value of the ERC-1967 beacon slot for\r\n     * efficiency.\r\n     */\r\n    function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {\r\n        _setBeacon(newBeacon);\r\n        emit BeaconUpgraded(newBeacon);\r\n\r\n        if (data.length > 0) {\r\n            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\r\n        } else {\r\n            _checkNonPayable();\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev Reverts if `msg.value` is not zero. It can be used to avoid `msg.value` stuck in the contract\r\n     * if an upgrade doesn't perform an initialization call.\r\n     */\r\n    function _checkNonPayable() private {\r\n        if (msg.value > 0) {\r\n            revert ERC1967NonPayable();\r\n        }\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/proxy/Proxy.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/Proxy.sol)\r\n\r\npragma solidity ^0.8.20;\r\n\r\n/**\r\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\r\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\r\n * be specified by overriding the virtual {_implementation} function.\r\n *\r\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\r\n * different contract through the {_delegate} function.\r\n *\r\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\r\n */\r\nabstract contract Proxy {\r\n    /**\r\n     * @dev Delegates the current call to `implementation`.\r\n     *\r\n     * This function does not return to its internal call site, it will return directly to the external caller.\r\n     */\r\n    function _delegate(address implementation) internal virtual {\r\n        assembly {\r\n            // Copy msg.data. We take full control of memory in this inline assembly\r\n            // block because it will not return to Solidity code. We overwrite the\r\n            // Solidity scratch pad at memory position 0.\r\n            calldatacopy(0, 0, calldatasize())\r\n\r\n            // Call the implementation.\r\n            // out and outsize are 0 because we don't know the size yet.\r\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\r\n\r\n            // Copy the returned data.\r\n            returndatacopy(0, 0, returndatasize())\r\n\r\n            switch result\r\n            // delegatecall returns 0 on error.\r\n            case 0 {\r\n                revert(0, returndatasize())\r\n            }\r\n            default {\r\n                return(0, returndatasize())\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback\r\n     * function and {_fallback} should delegate.\r\n     */\r\n    function _implementation() internal view virtual returns (address);\r\n\r\n    /**\r\n     * @dev Delegates the current call to the address returned by `_implementation()`.\r\n     *\r\n     * This function does not return to its internal call site, it will return directly to the external caller.\r\n     */\r\n    function _fallback() internal virtual {\r\n        _delegate(_implementation());\r\n    }\r\n\r\n    /**\r\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\r\n     * function in the contract matches the call data.\r\n     */\r\n    fallback() external payable virtual {\r\n        _fallback();\r\n    }\r\n}\r\n\r\n\r\n// File @openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol@v5.0.1\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\n// OpenZeppelin Contracts (last updated v5.0.0) (proxy/ERC1967/ERC1967Proxy.sol)\r\n\r\npragma solidity ^0.8.20;\r\n\r\n\r\n/**\r\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\r\n * implementation address that can be changed. This address is stored in storage in the location specified by\r\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\r\n * implementation behind the proxy.\r\n */\r\ncontract ERC1967Proxy is Proxy {\r\n    /**\r\n     * @dev Initializes the upgradeable proxy with an initial implementation specified by `implementation`.\r\n     *\r\n     * If `_data` is nonempty, it's used as data in a delegate call to `implementation`. This will typically be an\r\n     * encoded function call, and allows initializing the storage of the proxy like a Solidity constructor.\r\n     *\r\n     * Requirements:\r\n     *\r\n     * - If `data` is empty, `msg.value` must be zero.\r\n     */\r\n    constructor(address implementation, bytes memory _data) payable {\r\n        ERC1967Utils.upgradeToAndCall(implementation, _data);\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the current implementation address.\r\n     *\r\n     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using\r\n     * the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\r\n     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\r\n     */\r\n    function _implementation() internal view virtual override returns (address) {\r\n        return ERC1967Utils.getImplementation();\r\n    }\r\n}\r\n\r\n\r\n// File contracts/StablecoinProxy.sol\r\n\r\n// Original license: SPDX_License_Identifier: MIT\r\npragma solidity 0.8.26;\r\n\r\n/**\r\n * @dev Proxy to interact with {StablecoinUpgradeable}.\r\n *\r\n * @custom:security-contact bugs@ripple.com\r\n **/\r\ncontract StablecoinProxy is ERC1967Proxy {\r\n\r\n    constructor (address _delegate, bytes memory _data)  ERC1967Proxy(_delegate, _data)  {\r\n    }\r\n\r\n    /**\r\n     * @dev Returns the implementation address of the contract that executes a transaction.\r\n     */\r\n    function getImplementation() public view returns (address) {\r\n        return _implementation();\r\n    }\r\n\r\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.26+commit.8a97fa7a","compilerSettings":{"metadata":{"bytecodeHash":"ipfs"},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":[]},"name":"StablecoinProxy","fullyQualifiedName":"StablecoinProxy.sol:StablecoinProxy"},"runtimeBytecode":{"onchainBytecode":"0x608060405260043610601b575f3560e01c8063aaf10f42146023575b60216050565b005b348015602d575f80fd5b506034605e565b6040516001600160a01b03909116815260200160405180910390f35b605c6058606a565b609b565b565b5f6065606a565b905090565b5f60657f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b365f80375f80365f845af43d5f803e80801560b4573d5ff35b3d5ffdfea2646970667358221220473055829f4395ba8d97d9555c6283b50ddb7da794764971148dd577253e790164736f6c634300081a0033","recompiledBytecode":"0x608060405260043610601b575f3560e01c8063aaf10f42146023575b60216050565b005b348015602d575f80fd5b506034605e565b6040516001600160a01b03909116815260200160405180910390f35b605c6058606a565b609b565b565b5f6065606a565b905090565b5f60657f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc546001600160a01b031690565b365f80375f80365f845af43d5f803e80801560b4573d5ff35b3d5ffdfea2646970667358221220bc2ba2fac4310e904597eb3f89f542ecade77a9ec8cdbe62c5be14e088d986fc64736f6c634300081a0033","sourceMap":"23008:369:0:-:0;;;;;;;;;;;;;;;;;;20980:11;:9;:11::i;:::-;23008:369;23270:102;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;178:32:1;;;160:51;;148:2;133:18;23270:102:0;;;;;;;20645:85;20694:28;20704:17;:15;:17::i;:::-;20694:9;:28::i;:::-;20645:85::o;23270:102::-;23320:7;23347:17;:15;:17::i;:::-;23340:24;;23270:102;:::o;22629:134::-;22696:7;22723:32;12632:66;13366:53;-1:-1:-1;;;;;13366:53:0;;13287:140;19235:918;19578:14;19575:1;19572;19559:34;19796:1;19793;19777:14;19774:1;19758:14;19751:5;19738:60;19875:16;19872:1;19869;19854:38;19915:6;19984:68;;;;20103:16;20100:1;20093:27;19984:68;20020:16;20017:1;20010:27","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220bc2ba2fac4310e904597eb3f89f542ecade77a9ec8cdbe62c5be14e088d986fc64736f6c634300081a0033","offset":185}},"immutableReferences":{},"transformations":[{"id":"1","type":"replace","offset":185,"reason":"cborAuxdata"}],"transformationValues":{"cborAuxdata":{"1":"0xa2646970667358221220473055829f4395ba8d97d9555c6283b50ddb7da794764971148dd577253e790164736f6c634300081a0033"}}},"proxyResolution":{"isProxy":true,"proxyType":"EIP1967Proxy","implementations":[{"address":"0x9747a0d261c2d56Eb93f542068e5d1E23170fa9e","name":"StablecoinUpgradeableV2"}]},"deployment":{"transactionHash":"0x811c963004b19c2e3724850cda6bffd7cab7ff8f34d5670f86b51a9e1390327d","blockNumber":"20492031","transactionIndex":"276","deployer":"0x3BAf6263aD9C9D0854405B4Cfe4310c556a3e6ab"},"matchId":"5838909","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2024-12-25T16:29:56Z","match":"match","chainId":"1","address":"0x8292Bb45bf1Ee4d140127049757C2E0fF06317eD"}