{ "address": "0x5d3A779CEa67947927bF78c61473778c46A97236", "abi": [ { "inputs": [], "name": "NotCrossChainCall", "type": "error" }, { "inputs": [ { "internalType": "uint256", "name": "version", "type": "uint256" } ], "name": "UInitializableAlreadyInitializedError", "type": "error" }, { "inputs": [], "name": "UInitializableNotInitializingError", "type": "error" }, { "inputs": [], "name": "UInitializableZeroVersionError", "type": "error" }, { "inputs": [ { "internalType": "address", "name": "sender", "type": "address" } ], "name": "UOwnableNotOwnerError", "type": "error" }, { "inputs": [ { "internalType": "address", "name": "sender", "type": "address" } ], "name": "UOwnableNotPendingOwnerError", "type": "error" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint256", "name": "version", "type": "uint256" } ], "name": "Initialized", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "OwnerUpdated", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "newPendingOwner", "type": "address" } ], "name": "PendingOwnerUpdated", "type": "event" }, { "inputs": [], "name": "L2_CROSS_DOMAIN_MESSENGER_ADDRESS", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "acceptOwner", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "crossChainRestricted", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address payable", "name": "to", "type": "address" }, { "internalType": "bytes", "name": "data", "type": "bytes" }, { "internalType": "uint256", "name": "value", "type": "uint256" } ], "name": "execute", "outputs": [ { "internalType": "bytes", "name": "ret", "type": "bytes" } ], "stateMutability": "payable", "type": "function" }, { "inputs": [], "name": "initialize", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "pendingOwner", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "newPendingOwner", "type": "address" } ], "name": "updatePendingOwner", "outputs": [], "stateMutability": "nonpayable", "type": "function" } ], "transactionHash": "0xf0f1543350fb97406305e7df954643540c0996450b690025784accc6d05dca29", "receipt": { "to": null, "from": "0x66a7fDB96C583c59597de16d8b2B989231415339", "contractAddress": "0x5d3A779CEa67947927bF78c61473778c46A97236", "transactionIndex": 0, "gasUsed": "812423", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x1571343ca045ef23a47b5102691218653b3412781e56fe09fac889e17373d1fe", "transactionHash": "0xf0f1543350fb97406305e7df954643540c0996450b690025784accc6d05dca29", "logs": [], "blockNumber": 4020094, "cumulativeGasUsed": "812423", "status": 1, "byzantium": true }, "args": [], "numDeployments": 1, "solcInputHash": "0954eb4c5a9afab2c0aa2d884eb92458", "metadata": "{\"compiler\":{\"version\":\"0.8.15+commit.e14f2714\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"name\":\"NotCrossChainCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"version\",\"type\":\"uint256\"}],\"name\":\"UInitializableAlreadyInitializedError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UInitializableNotInitializingError\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"UInitializableZeroVersionError\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"UOwnableNotOwnerError\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"UOwnableNotPendingOwnerError\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"version\",\"type\":\"uint256\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnerUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newPendingOwner\",\"type\":\"address\"}],\"name\":\"PendingOwnerUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"L2_CROSS_DOMAIN_MESSENGER_ADDRESS\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"acceptOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"crossChainRestricted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address payable\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"execute\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"ret\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pendingOwner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newPendingOwner\",\"type\":\"address\"}],\"name\":\"updatePendingOwner\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"This contract is designed to act as an owner of any Ownable contract, allowing Cross Chain Ownership without modification to the underlying ownable contract. This contract is specific to the Optimism L2-side and should not be used on other chains. See {UCrossChainOwner} for initialization and usage.\",\"kind\":\"dev\",\"methods\":{\"acceptOwner()\":{\"details\":\"Can only be called by the pending owner to ensure correctness. Calls to the `_beforeAcceptOwner` hook to perform logic before updating ownership.\"},\"updatePendingOwner(address)\":{\"details\":\"Can only be called by the current owner New owner does not take affect until that address calls `acceptOwner()`\",\"params\":{\"newPendingOwner\":\"New pending owner address\"}}},\"title\":\"UCrossChainOwner_Arbitrum\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"acceptOwner()\":{\"notice\":\"Accepts and transfers the ownership of the contract to the pending owner\"},\"updatePendingOwner(address)\":{\"notice\":\"Updates the new pending owner\"}},\"notice\":\"Contract to act as an owner of other contracts\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"@equilibria/root/control/unstructured/CrossChainOwner/UCrossChainOwner_Optimism.sol\":\"UCrossChainOwner_Optimism\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[]},\"sources\":{\"@equilibria/root/control/unstructured/CrossChainOwnable/UCrossChainOwnable.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/crosschain/CrossChainEnabled.sol\\\";\\nimport \\\"../UOwnable.sol\\\";\\nimport \\\"../../../storage/UStorage.sol\\\";\\n\\n/**\\n * @title UCrossChainOwnable\\n * @notice Library to manage the cross-chain ownership lifecycle of upgradeable contracts.\\n * @dev This contract has been extended from the Open Zeppelin library to include an\\n * unstructured storage pattern so that it can be safely mixed in with upgradeable\\n * contracts without affecting their storage patterns through inheritance.\\n *\\n * Upon initialization, the `owner` will be set to the `msg.sender` of the initialize method.\\n * Ownership should then be transferred to the cross-chain owner via the `updatePendingOwner`\\n * and `acceptedPending` owner methods. Upon accepting ownership via the cross-chain address,\\n * a fuse will be tripped, preventing same-chain ownership going forward.\\n */\\nabstract contract UCrossChainOwnable is UOwnable, CrossChainEnabled {\\n BoolStorage private constant _crossChainRestricted = BoolStorage.wrap(keccak256(\\\"equilibria.root.UCrossChainOwnable.crossChainRestricted\\\"));\\n function crossChainRestricted() public view returns (bool) { return _crossChainRestricted.read(); }\\n\\n function _beforeAcceptOwner() internal override {\\n if (!crossChainRestricted()) _crossChainRestricted.store(true);\\n }\\n\\n function _sender() internal view override returns (address) {\\n if (crossChainRestricted()) return _crossChainSender();\\n return msg.sender;\\n }\\n}\\n\",\"keccak256\":\"0x788d922631328881e5e90a5e3d45260f4b74a633005f2aee77c17e01661aa053\",\"license\":\"Apache-2.0\"},\"@equilibria/root/control/unstructured/CrossChainOwnable/UCrossChainOwnable_Optimism.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/crosschain/optimism/CrossChainEnabledOptimism.sol\\\";\\nimport \\\"./UCrossChainOwnable.sol\\\";\\n\\n/**\\n * @title UCrossChainOwnable_Optimism\\n * @notice Library to manage the cross-chain ownership lifecycle of upgradeable contracts.\\n * @dev This contract has been extended from the Open Zeppelin library to include an\\n * unstructured storage pattern so that it can be safely mixed in with upgradeable\\n * contracts without affecting their storage patterns through inheritance. This contract\\n * is specific to the Optimism L2-side and should not be used on other chains.\\n *\\n * See {UCrossChainOwnable} for initialization and update usage.\\n */\\nabstract contract UCrossChainOwnable_Optimism is CrossChainEnabledOptimism, UCrossChainOwnable {\\n /// @dev System address for the CrossDomainMessenger. This address is ONLY valid on the L2 side\\n address public constant L2_CROSS_DOMAIN_MESSENGER_ADDRESS = address(0x4200000000000000000000000000000000000007);\\n\\n constructor() CrossChainEnabledOptimism(L2_CROSS_DOMAIN_MESSENGER_ADDRESS) {}\\n}\\n\",\"keccak256\":\"0x095366e6c3ee48768bf950e9537f54ba6bfde01912945cedbed0c1278a844841\",\"license\":\"Apache-2.0\"},\"@equilibria/root/control/unstructured/CrossChainOwner/UCrossChainOwner.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"../CrossChainOwnable/UCrossChainOwnable.sol\\\";\\n\\n/**\\n * @title UCrossChainOwner\\n * @notice Contract to act as an owner of other contracts\\n * @dev This contract is designed to act as an owner of any Ownable contract, allowing\\n * Cross Chain Ownership without modification to the underlying ownable contract\\n */\\nabstract contract UCrossChainOwner is UCrossChainOwnable {\\n function initialize() external initializer(1) {\\n super.__UOwnable__initialize();\\n }\\n\\n function execute(\\n address payable to,\\n bytes memory data,\\n uint256 value\\n ) payable external onlyOwner returns (bytes memory ret) {\\n if (data.length == 0) {\\n Address.sendValue(to, value);\\n } else {\\n ret = Address.functionCallWithValue(to, data, value);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x6f5d1831033ddf842d777c8ce4003e7b8a9053ce314ba81ec90210444b5e5d5d\",\"license\":\"Apache-2.0\"},\"@equilibria/root/control/unstructured/CrossChainOwner/UCrossChainOwner_Optimism.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"../CrossChainOwnable/UCrossChainOwnable_Optimism.sol\\\";\\nimport \\\"./UCrossChainOwner.sol\\\";\\n\\n/**\\n * @title UCrossChainOwner_Arbitrum\\n * @notice Contract to act as an owner of other contracts\\n * @dev This contract is designed to act as an owner of any Ownable contract, allowing\\n * Cross Chain Ownership without modification to the underlying ownable contract. This contract\\n * is specific to the Optimism L2-side and should not be used on other chains.\\n *\\n * See {UCrossChainOwner} for initialization and usage.\\n */\\ncontract UCrossChainOwner_Optimism is UCrossChainOwner, UCrossChainOwnable_Optimism { }\\n\",\"keccak256\":\"0x4de887c0907b2a97737cbd49522ea34d5bed76c0a92ded57e56c039c815951d0\",\"license\":\"Apache-2.0\"},\"@equilibria/root/control/unstructured/UInitializable.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/Address.sol\\\";\\nimport \\\"../../storage/UStorage.sol\\\";\\n\\n/**\\n * @title UInitializable\\n * @notice Library to manage the initialization lifecycle of upgradeable contracts\\n * @dev `UInitializable` allows the creation of pseudo-constructors for upgradeable contracts. One\\n * `initializer` should be declared per top-level contract. Child contracts can use the `onlyInitializer`\\n * modifier to tag their internal initialization functions to ensure that they can only be called\\n * from a top-level `initializer` or a constructor.\\n */\\nabstract contract UInitializable {\\n error UInitializableZeroVersionError();\\n error UInitializableAlreadyInitializedError(uint256 version);\\n error UInitializableNotInitializingError();\\n\\n event Initialized(uint256 version);\\n\\n /// @dev The initialized flag\\n Uint256Storage private constant _version = Uint256Storage.wrap(keccak256(\\\"equilibria.root.UInitializable.version\\\"));\\n\\n /// @dev The initializing flag\\n BoolStorage private constant _initializing = BoolStorage.wrap(keccak256(\\\"equilibria.root.UInitializable.initializing\\\"));\\n\\n /// @dev Can only be called once per version, `version` is 1-indexed\\n modifier initializer(uint256 version) {\\n if (version == 0) revert UInitializableZeroVersionError();\\n if (_version.read() >= version) revert UInitializableAlreadyInitializedError(version);\\n\\n _version.store(version);\\n _initializing.store(true);\\n\\n _;\\n\\n _initializing.store(false);\\n emit Initialized(version);\\n }\\n\\n /// @dev Can only be called from an initializer or constructor\\n modifier onlyInitializer() {\\n if (!_constructing() && !_initializing.read()) revert UInitializableNotInitializingError();\\n _;\\n }\\n\\n /**\\n * @notice Returns whether the contract is currently being constructed\\n * @dev {Address.isContract} returns false for contracts currently in the process of being constructed\\n * @return Whether the contract is currently being constructed\\n */\\n function _constructing() private view returns (bool) {\\n return !Address.isContract(address(this));\\n }\\n}\\n\",\"keccak256\":\"0xd2743d8fcc220ed2ccdc0bba1db0a3e107741bd5c0cac47ca8c0b5a00ba2fd7f\",\"license\":\"Apache-2.0\"},\"@equilibria/root/control/unstructured/UOwnable.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"./UInitializable.sol\\\";\\nimport \\\"../../storage/UStorage.sol\\\";\\n\\n/**\\n * @title UOwnable\\n * @notice Library to manage the ownership lifecycle of upgradeable contracts.\\n * @dev This contract has been extended from the Open Zeppelin library to include an\\n * unstructured storage pattern so that it can be safely mixed in with upgradeable\\n * contracts without affecting their storage patterns through inheritance.\\n */\\nabstract contract UOwnable is UInitializable {\\n event OwnerUpdated(address indexed newOwner);\\n event PendingOwnerUpdated(address indexed newPendingOwner);\\n\\n error UOwnableNotOwnerError(address sender);\\n error UOwnableNotPendingOwnerError(address sender);\\n\\n /// @dev The owner address\\n AddressStorage private constant _owner = AddressStorage.wrap(keccak256(\\\"equilibria.root.UOwnable.owner\\\"));\\n function owner() public view returns (address) { return _owner.read(); }\\n\\n /// @dev The pending owner address\\n AddressStorage private constant _pendingOwner = AddressStorage.wrap(keccak256(\\\"equilibria.root.UOwnable.pendingOwner\\\"));\\n function pendingOwner() public view returns (address) { return _pendingOwner.read(); }\\n\\n /**\\n * @notice Initializes the contract setting `msg.sender` as the initial owner\\n */\\n function __UOwnable__initialize() internal onlyInitializer {\\n _updateOwner(_sender());\\n }\\n\\n /**\\n * @notice Updates the new pending owner\\n * @dev Can only be called by the current owner\\n * New owner does not take affect until that address calls `acceptOwner()`\\n * @param newPendingOwner New pending owner address\\n */\\n function updatePendingOwner(address newPendingOwner) public onlyOwner {\\n _pendingOwner.store(newPendingOwner);\\n emit PendingOwnerUpdated(newPendingOwner);\\n }\\n\\n /**\\n * @notice Accepts and transfers the ownership of the contract to the pending owner\\n * @dev Can only be called by the pending owner to ensure correctness. Calls to the `_beforeAcceptOwner` hook\\n * to perform logic before updating ownership.\\n */\\n function acceptOwner() public {\\n _beforeAcceptOwner();\\n\\n if (_sender() != pendingOwner()) revert UOwnableNotPendingOwnerError(_sender());\\n\\n _updateOwner(pendingOwner());\\n updatePendingOwner(address(0));\\n }\\n\\n\\n /// @dev Hook for inheriting contracts to perform logic before accepting ownership\\n function _beforeAcceptOwner() internal virtual {}\\n\\n /**\\n * @notice Updates the owner address\\n * @param newOwner New owner address\\n */\\n function _updateOwner(address newOwner) private {\\n _owner.store(newOwner);\\n emit OwnerUpdated(newOwner);\\n }\\n\\n function _sender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n /// @dev Throws if called by any account other than the owner\\n modifier onlyOwner {\\n if (owner() != _sender()) revert UOwnableNotOwnerError(_sender());\\n _;\\n }\\n}\\n\",\"keccak256\":\"0x690594d8a7fcfc46c35741e6559ce4dd7f44c377a3ef98ff0674a0d68979d0a4\",\"license\":\"Apache-2.0\"},\"@equilibria/root/number/types/Fixed18.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/SignedMath.sol\\\";\\nimport \\\"./UFixed18.sol\\\";\\nimport \\\"./PackedFixed18.sol\\\";\\n\\n/// @dev Fixed18 type\\ntype Fixed18 is int256;\\nusing Fixed18Lib for Fixed18 global;\\ntype Fixed18Storage is bytes32;\\nusing Fixed18StorageLib for Fixed18Storage global;\\n\\n/**\\n * @title Fixed18Lib\\n * @notice Library for the signed fixed-decimal type.\\n */\\nlibrary Fixed18Lib {\\n error Fixed18OverflowError(uint256 value);\\n error Fixed18PackingOverflowError(int256 value);\\n error Fixed18PackingUnderflowError(int256 value);\\n\\n int256 private constant BASE = 1e18;\\n Fixed18 public constant ZERO = Fixed18.wrap(0);\\n Fixed18 public constant ONE = Fixed18.wrap(BASE);\\n Fixed18 public constant NEG_ONE = Fixed18.wrap(-1 * BASE);\\n Fixed18 public constant MAX = Fixed18.wrap(type(int256).max);\\n Fixed18 public constant MIN = Fixed18.wrap(type(int256).min);\\n\\n /**\\n * @notice Creates a signed fixed-decimal from an unsigned fixed-decimal\\n * @param a Unsigned fixed-decimal\\n * @return New signed fixed-decimal\\n */\\n function from(UFixed18 a) internal pure returns (Fixed18) {\\n uint256 value = UFixed18.unwrap(a);\\n if (value > uint256(type(int256).max)) revert Fixed18OverflowError(value);\\n return Fixed18.wrap(int256(value));\\n }\\n\\n /**\\n * @notice Creates a signed fixed-decimal from a sign and an unsigned fixed-decimal\\n * @param s Sign\\n * @param m Unsigned fixed-decimal magnitude\\n * @return New signed fixed-decimal\\n */\\n function from(int256 s, UFixed18 m) internal pure returns (Fixed18) {\\n if (s > 0) return from(m);\\n if (s < 0) return Fixed18.wrap(-1 * Fixed18.unwrap(from(m)));\\n return ZERO;\\n }\\n\\n /**\\n * @notice Creates a signed fixed-decimal from a signed integer\\n * @param a Signed number\\n * @return New signed fixed-decimal\\n */\\n function from(int256 a) internal pure returns (Fixed18) {\\n return Fixed18.wrap(a * BASE);\\n }\\n\\n /**\\n * @notice Creates a packed signed fixed-decimal from an signed fixed-decimal\\n * @param a signed fixed-decimal\\n * @return New packed signed fixed-decimal\\n */\\n function pack(Fixed18 a) internal pure returns (PackedFixed18) {\\n int256 value = Fixed18.unwrap(a);\\n if (value > type(int128).max) revert Fixed18PackingOverflowError(value);\\n if (value < type(int128).min) revert Fixed18PackingUnderflowError(value);\\n return PackedFixed18.wrap(int128(value));\\n }\\n\\n /**\\n * @notice Returns whether the signed fixed-decimal is equal to zero.\\n * @param a Signed fixed-decimal\\n * @return Whether the signed fixed-decimal is zero.\\n */\\n function isZero(Fixed18 a) internal pure returns (bool) {\\n return Fixed18.unwrap(a) == 0;\\n }\\n\\n /**\\n * @notice Adds two signed fixed-decimals `a` and `b` together\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Resulting summed signed fixed-decimal\\n */\\n function add(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(Fixed18.unwrap(a) + Fixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Subtracts signed fixed-decimal `b` from `a`\\n * @param a Signed fixed-decimal to subtract from\\n * @param b Signed fixed-decimal to subtract\\n * @return Resulting subtracted signed fixed-decimal\\n */\\n function sub(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(Fixed18.unwrap(a) - Fixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Multiplies two signed fixed-decimals `a` and `b` together\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Resulting multiplied signed fixed-decimal\\n */\\n function mul(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(Fixed18.unwrap(a) * Fixed18.unwrap(b) / BASE);\\n }\\n\\n /**\\n * @notice Divides signed fixed-decimal `a` by `b`\\n * @param a Signed fixed-decimal to divide\\n * @param b Signed fixed-decimal to divide by\\n * @return Resulting divided signed fixed-decimal\\n */\\n function div(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(Fixed18.unwrap(a) * BASE / Fixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Divides unsigned fixed-decimal `a` by `b`\\n * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0`, `MAX` for `n/0`, and `MIN` for `-n/0`.\\n * @param a Unsigned fixed-decimal to divide\\n * @param b Unsigned fixed-decimal to divide by\\n * @return Resulting divided unsigned fixed-decimal\\n */\\n function unsafeDiv(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n if (isZero(b)) {\\n if (gt(a, ZERO)) return MAX;\\n if (lt(a, ZERO)) return MIN;\\n return ONE;\\n } else {\\n return div(a, b);\\n }\\n }\\n\\n /**\\n * @notice Computes a * b / c without loss of precision due to BASE conversion\\n * @param a First signed fixed-decimal\\n * @param b Signed number to multiply by\\n * @param c Signed number to divide by\\n * @return Resulting computation\\n */\\n function muldiv(Fixed18 a, int256 b, int256 c) internal pure returns (Fixed18) {\\n return muldiv(a, Fixed18.wrap(b), Fixed18.wrap(c));\\n }\\n\\n /**\\n * @notice Computes a * b / c without loss of precision due to BASE conversion\\n * @param a First signed fixed-decimal\\n * @param b Signed fixed-decimal to multiply by\\n * @param c Signed fixed-decimal to divide by\\n * @return Resulting computation\\n */\\n function muldiv(Fixed18 a, Fixed18 b, Fixed18 c) internal pure returns (Fixed18) {\\n return Fixed18.wrap(Fixed18.unwrap(a) * Fixed18.unwrap(b) / Fixed18.unwrap(c));\\n }\\n\\n /**\\n * @notice Returns whether signed fixed-decimal `a` is equal to `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Whether `a` is equal to `b`\\n */\\n function eq(Fixed18 a, Fixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 1;\\n }\\n\\n /**\\n * @notice Returns whether signed fixed-decimal `a` is greater than `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Whether `a` is greater than `b`\\n */\\n function gt(Fixed18 a, Fixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 2;\\n }\\n\\n /**\\n * @notice Returns whether signed fixed-decimal `a` is less than `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Whether `a` is less than `b`\\n */\\n function lt(Fixed18 a, Fixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 0;\\n }\\n\\n /**\\n * @notice Returns whether signed fixed-decimal `a` is greater than or equal to `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Whether `a` is greater than or equal to `b`\\n */\\n function gte(Fixed18 a, Fixed18 b) internal pure returns (bool) {\\n return gt(a, b) || eq(a, b);\\n }\\n\\n /**\\n * @notice Returns whether signed fixed-decimal `a` is less than or equal to `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Whether `a` is less than or equal to `b`\\n */\\n function lte(Fixed18 a, Fixed18 b) internal pure returns (bool) {\\n return lt(a, b) || eq(a, b);\\n }\\n\\n /**\\n * @notice Compares the signed fixed-decimals `a` and `b`\\n * @dev Returns: 2 for greater than\\n * 1 for equal to\\n * 0 for less than\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Compare result of `a` and `b`\\n */\\n function compare(Fixed18 a, Fixed18 b) internal pure returns (uint256) {\\n (int256 au, int256 bu) = (Fixed18.unwrap(a), Fixed18.unwrap(b));\\n if (au > bu) return 2;\\n if (au < bu) return 0;\\n return 1;\\n }\\n\\n /**\\n * @notice Returns a signed fixed-decimal representing the ratio of `a` over `b`\\n * @param a First signed number\\n * @param b Second signed number\\n * @return Ratio of `a` over `b`\\n */\\n function ratio(int256 a, int256 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(a * BASE / b);\\n }\\n\\n /**\\n * @notice Returns the minimum of signed fixed-decimals `a` and `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Minimum of `a` and `b`\\n */\\n function min(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(SignedMath.min(Fixed18.unwrap(a), Fixed18.unwrap(b)));\\n }\\n\\n /**\\n * @notice Returns the maximum of signed fixed-decimals `a` and `b`\\n * @param a First signed fixed-decimal\\n * @param b Second signed fixed-decimal\\n * @return Maximum of `a` and `b`\\n */\\n function max(Fixed18 a, Fixed18 b) internal pure returns (Fixed18) {\\n return Fixed18.wrap(SignedMath.max(Fixed18.unwrap(a), Fixed18.unwrap(b)));\\n }\\n\\n /**\\n * @notice Converts the signed fixed-decimal into an integer, truncating any decimal portion\\n * @param a Signed fixed-decimal\\n * @return Truncated signed number\\n */\\n function truncate(Fixed18 a) internal pure returns (int256) {\\n return Fixed18.unwrap(a) / BASE;\\n }\\n\\n /**\\n * @notice Returns the sign of the signed fixed-decimal\\n * @dev Returns: -1 for negative\\n * 0 for zero\\n * 1 for positive\\n * @param a Signed fixed-decimal\\n * @return Sign of the signed fixed-decimal\\n */\\n function sign(Fixed18 a) internal pure returns (int256) {\\n if (Fixed18.unwrap(a) > 0) return 1;\\n if (Fixed18.unwrap(a) < 0) return -1;\\n return 0;\\n }\\n\\n /**\\n * @notice Returns the absolute value of the signed fixed-decimal\\n * @param a Signed fixed-decimal\\n * @return Absolute value of the signed fixed-decimal\\n */\\n function abs(Fixed18 a) internal pure returns (UFixed18) {\\n return UFixed18.wrap(SignedMath.abs(Fixed18.unwrap(a)));\\n }\\n}\\n\\nlibrary Fixed18StorageLib {\\n function read(Fixed18Storage self) internal view returns (Fixed18 value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n function store(Fixed18Storage self, Fixed18 value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x613587461ef3437ef33229cdda7d34ea746278721baf06e20b2e43977f43174d\",\"license\":\"Apache-2.0\"},\"@equilibria/root/number/types/PackedFixed18.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"./Fixed18.sol\\\";\\n\\n/// @dev PackedFixed18 type\\ntype PackedFixed18 is int128;\\nusing PackedFixed18Lib for PackedFixed18 global;\\n\\n/**\\n * @title PackedFixed18Lib\\n * @dev A packed version of the Fixed18 which takes up half the storage space (two PackedFixed18 can be packed\\n * into a single slot). Only valid within the range -1.7014118e+20 <= x <= 1.7014118e+20.\\n * @notice Library for the packed signed fixed-decimal type.\\n */\\nlibrary PackedFixed18Lib {\\n PackedFixed18 public constant MAX = PackedFixed18.wrap(type(int128).max);\\n PackedFixed18 public constant MIN = PackedFixed18.wrap(type(int128).min);\\n\\n /**\\n * @notice Creates an unpacked signed fixed-decimal from a packed signed fixed-decimal\\n * @param self packed signed fixed-decimal\\n * @return New unpacked signed fixed-decimal\\n */\\n function unpack(PackedFixed18 self) internal pure returns (Fixed18) {\\n return Fixed18.wrap(int256(PackedFixed18.unwrap(self)));\\n }\\n}\\n\",\"keccak256\":\"0xb52960cc8e3132e45d342bbbb1c6a96219022cd8557997933bd8250170268b64\",\"license\":\"Apache-2.0\"},\"@equilibria/root/number/types/PackedUFixed18.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"./UFixed18.sol\\\";\\n\\n/// @dev PackedUFixed18 type\\ntype PackedUFixed18 is uint128;\\nusing PackedUFixed18Lib for PackedUFixed18 global;\\n\\n/**\\n * @title PackedUFixed18Lib\\n * @dev A packed version of the UFixed18 which takes up half the storage space (two PackedUFixed18 can be packed\\n * into a single slot). Only valid within the range 0 <= x <= 3.4028237e+20.\\n * @notice Library for the packed unsigned fixed-decimal type.\\n */\\nlibrary PackedUFixed18Lib {\\n PackedUFixed18 public constant MAX = PackedUFixed18.wrap(type(uint128).max);\\n\\n /**\\n * @notice Creates an unpacked unsigned fixed-decimal from a packed unsigned fixed-decimal\\n * @param self packed unsigned fixed-decimal\\n * @return New unpacked unsigned fixed-decimal\\n */\\n function unpack(PackedUFixed18 self) internal pure returns (UFixed18) {\\n return UFixed18.wrap(uint256(PackedUFixed18.unwrap(self)));\\n }\\n}\\n\",\"keccak256\":\"0xb5c5cd32d6530b2fe75228b6be32ebcb7762f6d7988b85a6b85a289ce8256d51\",\"license\":\"Apache-2.0\"},\"@equilibria/root/number/types/UFixed18.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"@openzeppelin/contracts/utils/math/Math.sol\\\";\\nimport \\\"./Fixed18.sol\\\";\\nimport \\\"./PackedUFixed18.sol\\\";\\n\\n/// @dev UFixed18 type\\ntype UFixed18 is uint256;\\nusing UFixed18Lib for UFixed18 global;\\ntype UFixed18Storage is bytes32;\\nusing UFixed18StorageLib for UFixed18Storage global;\\n\\n/**\\n * @title UFixed18Lib\\n * @notice Library for the unsigned fixed-decimal type.\\n */\\nlibrary UFixed18Lib {\\n error UFixed18UnderflowError(int256 value);\\n error UFixed18PackingOverflowError(uint256 value);\\n\\n uint256 private constant BASE = 1e18;\\n UFixed18 public constant ZERO = UFixed18.wrap(0);\\n UFixed18 public constant ONE = UFixed18.wrap(BASE);\\n UFixed18 public constant MAX = UFixed18.wrap(type(uint256).max);\\n\\n /**\\n * @notice Creates a unsigned fixed-decimal from a signed fixed-decimal\\n * @param a Signed fixed-decimal\\n * @return New unsigned fixed-decimal\\n */\\n function from(Fixed18 a) internal pure returns (UFixed18) {\\n int256 value = Fixed18.unwrap(a);\\n if (value < 0) revert UFixed18UnderflowError(value);\\n return UFixed18.wrap(uint256(value));\\n }\\n\\n /**\\n * @notice Creates a unsigned fixed-decimal from a unsigned integer\\n * @param a Unsigned number\\n * @return New unsigned fixed-decimal\\n */\\n function from(uint256 a) internal pure returns (UFixed18) {\\n return UFixed18.wrap(a * BASE);\\n }\\n\\n /**\\n * @notice Creates a packed unsigned fixed-decimal from an unsigned fixed-decimal\\n * @param a unsigned fixed-decimal\\n * @return New packed unsigned fixed-decimal\\n */\\n function pack(UFixed18 a) internal pure returns (PackedUFixed18) {\\n uint256 value = UFixed18.unwrap(a);\\n if (value > type(uint128).max) revert UFixed18PackingOverflowError(value);\\n return PackedUFixed18.wrap(uint128(value));\\n }\\n\\n /**\\n * @notice Returns whether the unsigned fixed-decimal is equal to zero.\\n * @param a Unsigned fixed-decimal\\n * @return Whether the unsigned fixed-decimal is zero.\\n */\\n function isZero(UFixed18 a) internal pure returns (bool) {\\n return UFixed18.unwrap(a) == 0;\\n }\\n\\n /**\\n * @notice Adds two unsigned fixed-decimals `a` and `b` together\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Resulting summed unsigned fixed-decimal\\n */\\n function add(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(UFixed18.unwrap(a) + UFixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Subtracts unsigned fixed-decimal `b` from `a`\\n * @param a Unsigned fixed-decimal to subtract from\\n * @param b Unsigned fixed-decimal to subtract\\n * @return Resulting subtracted unsigned fixed-decimal\\n */\\n function sub(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(UFixed18.unwrap(a) - UFixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Multiplies two unsigned fixed-decimals `a` and `b` together\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Resulting multiplied unsigned fixed-decimal\\n */\\n function mul(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / BASE);\\n }\\n\\n /**\\n * @notice Divides unsigned fixed-decimal `a` by `b`\\n * @param a Unsigned fixed-decimal to divide\\n * @param b Unsigned fixed-decimal to divide by\\n * @return Resulting divided unsigned fixed-decimal\\n */\\n function div(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(UFixed18.unwrap(a) * BASE / UFixed18.unwrap(b));\\n }\\n\\n /**\\n * @notice Divides unsigned fixed-decimal `a` by `b`\\n * @dev Does not revert on divide-by-0, instead returns `ONE` for `0/0` and `MAX` for `n/0`.\\n * @param a Unsigned fixed-decimal to divide\\n * @param b Unsigned fixed-decimal to divide by\\n * @return Resulting divided unsigned fixed-decimal\\n */\\n function unsafeDiv(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n if (isZero(b)) {\\n return isZero(a) ? ONE : MAX;\\n } else {\\n return div(a, b);\\n }\\n }\\n\\n /**\\n * @notice Computes a * b / c without loss of precision due to BASE conversion\\n * @param a First unsigned fixed-decimal\\n * @param b Unsigned number to multiply by\\n * @param c Unsigned number to divide by\\n * @return Resulting computation\\n */\\n function muldiv(UFixed18 a, uint256 b, uint256 c) internal pure returns (UFixed18) {\\n return muldiv(a, UFixed18.wrap(b), UFixed18.wrap(c));\\n }\\n\\n /**\\n * @notice Computes a * b / c without loss of precision due to BASE conversion\\n * @param a First unsigned fixed-decimal\\n * @param b Unsigned fixed-decimal to multiply by\\n * @param c Unsigned fixed-decimal to divide by\\n * @return Resulting computation\\n */\\n function muldiv(UFixed18 a, UFixed18 b, UFixed18 c) internal pure returns (UFixed18) {\\n return UFixed18.wrap(UFixed18.unwrap(a) * UFixed18.unwrap(b) / UFixed18.unwrap(c));\\n }\\n\\n /**\\n * @notice Returns whether unsigned fixed-decimal `a` is equal to `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Whether `a` is equal to `b`\\n */\\n function eq(UFixed18 a, UFixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 1;\\n }\\n\\n /**\\n * @notice Returns whether unsigned fixed-decimal `a` is greater than `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Whether `a` is greater than `b`\\n */\\n function gt(UFixed18 a, UFixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 2;\\n }\\n\\n /**\\n * @notice Returns whether unsigned fixed-decimal `a` is less than `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Whether `a` is less than `b`\\n */\\n function lt(UFixed18 a, UFixed18 b) internal pure returns (bool) {\\n return compare(a, b) == 0;\\n }\\n\\n /**\\n * @notice Returns whether unsigned fixed-decimal `a` is greater than or equal to `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Whether `a` is greater than or equal to `b`\\n */\\n function gte(UFixed18 a, UFixed18 b) internal pure returns (bool) {\\n return gt(a, b) || eq(a, b);\\n }\\n\\n /**\\n * @notice Returns whether unsigned fixed-decimal `a` is less than or equal to `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Whether `a` is less than or equal to `b`\\n */\\n function lte(UFixed18 a, UFixed18 b) internal pure returns (bool) {\\n return lt(a, b) || eq(a, b);\\n }\\n\\n /**\\n * @notice Compares the unsigned fixed-decimals `a` and `b`\\n * @dev Returns: 2 for greater than\\n * 1 for equal to\\n * 0 for less than\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Compare result of `a` and `b`\\n */\\n function compare(UFixed18 a, UFixed18 b) internal pure returns (uint256) {\\n (uint256 au, uint256 bu) = (UFixed18.unwrap(a), UFixed18.unwrap(b));\\n if (au > bu) return 2;\\n if (au < bu) return 0;\\n return 1;\\n }\\n\\n /**\\n * @notice Returns a unsigned fixed-decimal representing the ratio of `a` over `b`\\n * @param a First unsigned number\\n * @param b Second unsigned number\\n * @return Ratio of `a` over `b`\\n */\\n function ratio(uint256 a, uint256 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(a * BASE / b);\\n }\\n\\n /**\\n * @notice Returns the minimum of unsigned fixed-decimals `a` and `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Minimum of `a` and `b`\\n */\\n function min(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(Math.min(UFixed18.unwrap(a), UFixed18.unwrap(b)));\\n }\\n\\n /**\\n * @notice Returns the maximum of unsigned fixed-decimals `a` and `b`\\n * @param a First unsigned fixed-decimal\\n * @param b Second unsigned fixed-decimal\\n * @return Maximum of `a` and `b`\\n */\\n function max(UFixed18 a, UFixed18 b) internal pure returns (UFixed18) {\\n return UFixed18.wrap(Math.max(UFixed18.unwrap(a), UFixed18.unwrap(b)));\\n }\\n\\n /**\\n * @notice Converts the unsigned fixed-decimal into an integer, truncating any decimal portion\\n * @param a Unsigned fixed-decimal\\n * @return Truncated unsigned number\\n */\\n function truncate(UFixed18 a) internal pure returns (uint256) {\\n return UFixed18.unwrap(a) / BASE;\\n }\\n}\\n\\nlibrary UFixed18StorageLib {\\n function read(UFixed18Storage self) internal view returns (UFixed18 value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n function store(UFixed18Storage self, UFixed18 value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\",\"keccak256\":\"0x8ebef1e6c717f565b9ed545a876b5692b4007e6485c99f39d363f7405e591792\",\"license\":\"Apache-2.0\"},\"@equilibria/root/storage/UStorage.sol\":{\"content\":\"// SPDX-License-Identifier: Apache-2.0\\npragma solidity ^0.8.13;\\n\\nimport \\\"../number/types/UFixed18.sol\\\";\\n\\n/// @dev Stored boolean slot\\ntype BoolStorage is bytes32;\\nusing BoolStorageLib for BoolStorage global;\\n\\n/// @dev Stored uint256 slot\\ntype Uint256Storage is bytes32;\\nusing Uint256StorageLib for Uint256Storage global;\\n\\n/// @dev Stored int256 slot\\ntype Int256Storage is bytes32;\\nusing Int256StorageLib for Int256Storage global;\\n\\n/// @dev Stored address slot\\ntype AddressStorage is bytes32;\\nusing AddressStorageLib for AddressStorage global;\\n\\n/// @dev Stored bytes32 slot\\ntype Bytes32Storage is bytes32;\\nusing Bytes32StorageLib for Bytes32Storage global;\\n\\n/**\\n * @title BoolStorageLib\\n * @notice Library to manage storage and retrival of a boolean at a fixed storage slot\\n */\\nlibrary BoolStorageLib {\\n /**\\n * @notice Retrieves the stored value\\n * @param self Storage slot\\n * @return value Stored bool value\\n */\\n function read(BoolStorage self) internal view returns (bool value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n /**\\n * @notice Stores the value at the specific slot\\n * @param self Storage slot\\n * @param value boolean value to store\\n */\\n function store(BoolStorage self, bool value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\\n/**\\n * @title Uint256StorageLib\\n * @notice Library to manage storage and retrival of an uint256 at a fixed storage slot\\n */\\nlibrary Uint256StorageLib {\\n /**\\n * @notice Retrieves the stored value\\n * @param self Storage slot\\n * @return value Stored uint256 value\\n */\\n function read(Uint256Storage self) internal view returns (uint256 value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n /**\\n * @notice Stores the value at the specific slot\\n * @param self Storage slot\\n * @param value uint256 value to store\\n */\\n function store(Uint256Storage self, uint256 value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\\n/**\\n * @title Int256StorageLib\\n * @notice Library to manage storage and retrival of an int256 at a fixed storage slot\\n */\\nlibrary Int256StorageLib {\\n /**\\n * @notice Retrieves the stored value\\n * @param self Storage slot\\n * @return value Stored int256 value\\n */\\n function read(Int256Storage self) internal view returns (int256 value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n /**\\n * @notice Stores the value at the specific slot\\n * @param self Storage slot\\n * @param value int256 value to store\\n */\\n function store(Int256Storage self, int256 value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\\n/**\\n * @title AddressStorageLib\\n * @notice Library to manage storage and retrival of an address at a fixed storage slot\\n */\\nlibrary AddressStorageLib {\\n /**\\n * @notice Retrieves the stored value\\n * @param self Storage slot\\n * @return value Stored address value\\n */\\n function read(AddressStorage self) internal view returns (address value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n /**\\n * @notice Stores the value at the specific slot\\n * @param self Storage slot\\n * @param value address value to store\\n */\\n function store(AddressStorage self, address value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\\n/**\\n * @title Bytes32StorageLib\\n * @notice Library to manage storage and retrival of a bytes32 at a fixed storage slot\\n */\\nlibrary Bytes32StorageLib {\\n /**\\n * @notice Retrieves the stored value\\n * @param self Storage slot\\n * @return value Stored bytes32 value\\n */\\n function read(Bytes32Storage self) internal view returns (bytes32 value) {\\n assembly {\\n value := sload(self)\\n }\\n }\\n\\n /**\\n * @notice Stores the value at the specific slot\\n * @param self Storage slot\\n * @param value bytes32 value to store\\n */\\n function store(Bytes32Storage self, bytes32 value) internal {\\n assembly {\\n sstore(self, value)\\n }\\n }\\n}\\n\",\"keccak256\":\"0xe2b8491d1b5aa93f7e059e1a8f156b0ab37fef9ed973be97a64f2eabfc2cc172\",\"license\":\"Apache-2.0\"},\"@openzeppelin/contracts/crosschain/CrossChainEnabled.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/CrossChainEnabled.sol)\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"./errors.sol\\\";\\n\\n/**\\n * @dev Provides information for building cross-chain aware contracts. This\\n * abstract contract provides accessors and modifiers to control the execution\\n * flow when receiving cross-chain messages.\\n *\\n * Actual implementations of cross-chain aware contracts, which are based on\\n * this abstraction, will have to inherit from a bridge-specific\\n * specialization. Such specializations are provided under\\n * `crosschain//CrossChainEnabled.sol`.\\n *\\n * _Available since v4.6._\\n */\\nabstract contract CrossChainEnabled {\\n /**\\n * @dev Throws if the current function call is not the result of a\\n * cross-chain execution.\\n */\\n modifier onlyCrossChain() {\\n if (!_isCrossChain()) revert NotCrossChainCall();\\n _;\\n }\\n\\n /**\\n * @dev Throws if the current function call is not the result of a\\n * cross-chain execution initiated by `account`.\\n */\\n modifier onlyCrossChainSender(address expected) {\\n address actual = _crossChainSender();\\n if (expected != actual) revert InvalidCrossChainSender(actual, expected);\\n _;\\n }\\n\\n /**\\n * @dev Returns whether the current function call is the result of a\\n * cross-chain message.\\n */\\n function _isCrossChain() internal view virtual returns (bool);\\n\\n /**\\n * @dev Returns the address of the sender of the cross-chain message that\\n * triggered the current function call.\\n *\\n * IMPORTANT: Should revert with `NotCrossChainCall` if the current function\\n * call is not the result of a cross-chain message.\\n */\\n function _crossChainSender() internal view virtual returns (address);\\n}\\n\",\"keccak256\":\"0x1ec2f661e2b0bd06b245f7e847111d5b40d32380794bd2d791e89b0bdc3ef082\",\"license\":\"MIT\"},\"@openzeppelin/contracts/crosschain/errors.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/errors.sol)\\n\\npragma solidity ^0.8.4;\\n\\nerror NotCrossChainCall();\\nerror InvalidCrossChainSender(address actual, address expected);\\n\",\"keccak256\":\"0xa1e9b651a2427925598b49ef35da5930abc07859cfac5b9dfb1912f063a024b3\",\"license\":\"MIT\"},\"@openzeppelin/contracts/crosschain/optimism/CrossChainEnabledOptimism.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/optimism/CrossChainEnabledOptimism.sol)\\n\\npragma solidity ^0.8.4;\\n\\nimport \\\"../CrossChainEnabled.sol\\\";\\nimport \\\"./LibOptimism.sol\\\";\\n\\n/**\\n * @dev [Optimism](https://www.optimism.io/) specialization or the\\n * {CrossChainEnabled} abstraction.\\n *\\n * The messenger (`CrossDomainMessenger`) contract is provided and maintained by\\n * the optimism team. You can find the address of this contract on mainnet and\\n * kovan in the [deployments section of Optimism monorepo](https://github.com/ethereum-optimism/optimism/tree/develop/packages/contracts/deployments).\\n *\\n * _Available since v4.6._\\n */\\nabstract contract CrossChainEnabledOptimism is CrossChainEnabled {\\n /// @custom:oz-upgrades-unsafe-allow state-variable-immutable\\n address private immutable _messenger;\\n\\n /// @custom:oz-upgrades-unsafe-allow constructor\\n constructor(address messenger) {\\n _messenger = messenger;\\n }\\n\\n /**\\n * @dev see {CrossChainEnabled-_isCrossChain}\\n */\\n function _isCrossChain() internal view virtual override returns (bool) {\\n return LibOptimism.isCrossChain(_messenger);\\n }\\n\\n /**\\n * @dev see {CrossChainEnabled-_crossChainSender}\\n */\\n function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {\\n return LibOptimism.crossChainSender(_messenger);\\n }\\n}\\n\",\"keccak256\":\"0xcda7f2956ae99ccc290e73f43faa7fe42f8b8c56f44305bb6d534265da045b5b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/crosschain/optimism/LibOptimism.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/optimism/LibOptimism.sol)\\n\\npragma solidity ^0.8.4;\\n\\nimport {ICrossDomainMessenger as Optimism_Bridge} from \\\"../../vendor/optimism/ICrossDomainMessenger.sol\\\";\\nimport \\\"../errors.sol\\\";\\n\\n/**\\n * @dev Primitives for cross-chain aware contracts for [Optimism](https://www.optimism.io/).\\n * See the [documentation](https://community.optimism.io/docs/developers/bridge/messaging/#accessing-msg-sender)\\n * for the functionality used here.\\n */\\nlibrary LibOptimism {\\n /**\\n * @dev Returns whether the current function call is the result of a\\n * cross-chain message relayed by `messenger`.\\n */\\n function isCrossChain(address messenger) internal view returns (bool) {\\n return msg.sender == messenger;\\n }\\n\\n /**\\n * @dev Returns the address of the sender that triggered the current\\n * cross-chain message through `messenger`.\\n *\\n * NOTE: {isCrossChain} should be checked before trying to recover the\\n * sender, as it will revert with `NotCrossChainCall` if the current\\n * function call is not the result of a cross-chain message.\\n */\\n function crossChainSender(address messenger) internal view returns (address) {\\n if (!isCrossChain(messenger)) revert NotCrossChainCall();\\n\\n return Optimism_Bridge(messenger).xDomainMessageSender();\\n }\\n}\\n\",\"keccak256\":\"0x0cd9166d0017c0d250512dc18a8356cf0f55804e4b01585662b5e925083fb84b\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x2ccf9d2313a313d41a791505f2b5abfdc62191b5d4334f7f7a82691c088a1c87\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard math utilities missing in the Solidity language.\\n */\\nlibrary Math {\\n /**\\n * @dev Returns the largest of two numbers.\\n */\\n function max(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a >= b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two numbers.\\n */\\n function min(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two numbers. The result is rounded towards\\n * zero.\\n */\\n function average(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b) / 2 can overflow.\\n return (a & b) + (a ^ b) / 2;\\n }\\n\\n /**\\n * @dev Returns the ceiling of the division of two numbers.\\n *\\n * This differs from standard division with `/` in that it rounds up instead\\n * of rounding down.\\n */\\n function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\\n // (a + b - 1) / b can overflow on addition, so we distribute.\\n return a / b + (a % b == 0 ? 0 : 1);\\n }\\n}\\n\",\"keccak256\":\"0xc995bddbca1ae19788db9f8b61e63385edd3fddf89693b612d5abd1a275974d2\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/SignedMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Standard signed math utilities missing in the Solidity language.\\n */\\nlibrary SignedMath {\\n /**\\n * @dev Returns the largest of two signed numbers.\\n */\\n function max(int256 a, int256 b) internal pure returns (int256) {\\n return a >= b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the smallest of two signed numbers.\\n */\\n function min(int256 a, int256 b) internal pure returns (int256) {\\n return a < b ? a : b;\\n }\\n\\n /**\\n * @dev Returns the average of two signed numbers without overflow.\\n * The result is rounded towards zero.\\n */\\n function average(int256 a, int256 b) internal pure returns (int256) {\\n // Formula from the book \\\"Hacker's Delight\\\"\\n int256 x = (a & b) + ((a ^ b) >> 1);\\n return x + (int256(uint256(x) >> 255) & (a ^ b));\\n }\\n\\n /**\\n * @dev Returns the absolute unsigned value of a signed value.\\n */\\n function abs(int256 n) internal pure returns (uint256) {\\n unchecked {\\n // must be unchecked in order to support `n = type(int256).min`\\n return uint256(n >= 0 ? n : -n);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb3ebde1c8d27576db912d87c3560dab14adfb9cd001be95890ec4ba035e652e7\",\"license\":\"MIT\"},\"@openzeppelin/contracts/vendor/optimism/ICrossDomainMessenger.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (vendor/optimism/ICrossDomainMessenger.sol)\\npragma solidity >0.5.0 <0.9.0;\\n\\n/**\\n * @title ICrossDomainMessenger\\n */\\ninterface ICrossDomainMessenger {\\n /**********\\n * Events *\\n **********/\\n\\n event SentMessage(address indexed target, address sender, bytes message, uint256 messageNonce, uint256 gasLimit);\\n event RelayedMessage(bytes32 indexed msgHash);\\n event FailedRelayedMessage(bytes32 indexed msgHash);\\n\\n /*************\\n * Variables *\\n *************/\\n\\n function xDomainMessageSender() external view returns (address);\\n\\n /********************\\n * Public Functions *\\n ********************/\\n\\n /**\\n * Sends a cross domain message to the target messenger.\\n * @param _target Target contract address.\\n * @param _message Message to send to the target.\\n * @param _gasLimit Gas limit for the provided message.\\n */\\n function sendMessage(\\n address _target,\\n bytes calldata _message,\\n uint32 _gasLimit\\n ) external;\\n}\\n\",\"keccak256\":\"0x7e55d25ce89596017f1300edc0fed07bd22db98d3b67349cac9d293340d1ac4e\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "This contract is designed to act as an owner of any Ownable contract, allowing Cross Chain Ownership without modification to the underlying ownable contract. This contract is specific to the Optimism L2-side and should not be used on other chains. See {UCrossChainOwner} for initialization and usage.", "kind": "dev", "methods": { "acceptOwner()": { "details": "Can only be called by the pending owner to ensure correctness. Calls to the `_beforeAcceptOwner` hook to perform logic before updating ownership." }, "updatePendingOwner(address)": { "details": "Can only be called by the current owner New owner does not take affect until that address calls `acceptOwner()`", "params": { "newPendingOwner": "New pending owner address" } } }, "title": "UCrossChainOwner_Arbitrum", "version": 1 }, "userdoc": { "kind": "user", "methods": { "acceptOwner()": { "notice": "Accepts and transfers the ownership of the contract to the pending owner" }, "updatePendingOwner(address)": { "notice": "Updates the new pending owner" } }, "notice": "Contract to act as an owner of other contracts", "version": 1 }, "storageLayout": { "storage": [], "types": null } }