{"matchId":"14055788","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-01-17T16:10:31Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"497:958:4:-:0;;;929:34;;;;;;;;;-1:-1:-1;1045:5:0;:14;;-1:-1:-1;;;;;;1045:14:0;949:10:4;1045:14:0;;;;;1075:40;;949:10:4;;;;1075:40:0;;1045:5;;1075:40;1007:115;497:958:4;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d7aaaac8fac923c3688a2499f02549639e68ab7c9bff12588a7d729c85c0c75364736f6c634300081d0033","offset":2029}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"497:958:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;567:23;;;;;;;;;;-1:-1:-1;567:23:4;;;;;;;;;;;190:42:6;178:55;;;160:74;;148:2;133:18;567:23:4;;;;;;;1330:90;;;;;;;;;;-1:-1:-1;1330:90:4;;;;;:::i;:::-;;:::i;:::-;;690:20:0;;;;;;;;;;-1:-1:-1;690:20:0;;;;;;;;995:303:4;;;;;;;;;;-1:-1:-1;995:303:4;;;;;:::i;:::-;;:::i;1312:161:0:-;;;;;;;;;;-1:-1:-1;1312:161:0;;;;;:::i;:::-;;:::i;1330:90:4:-;778:5:0;;;;764:10;:19;756:44;;;;;;;1642:2:6;756:44:0;;;1624:21:6;1681:2;1661:18;;;1654:30;1720:14;1700:18;;;1693:42;1752:18;;756:44:0;;;;;;;;;1395:8:4::1;:20:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;1330:90::o;995:303::-;717:8;;;;703:10;:22;695:47;;;;;;;;;;;;;;;;;1087:14:::1;1107;1132:9;1127:167;1143:17:::0;;::::1;1127:167;;;1183:6;;1190:1;1183:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;1175:17;;1209:21;:5;:19;;;:21::i;:::-;1200:30:::0;-1:-1:-1;1242:10:4;;1238:49:::1;;1254:33;:14;::::0;::::1;1269:9:::0;1280:6;1254:14:::1;:33::i;:::-;1162:3;;1127:167;;;;1081:217;;995:303:::0;;;:::o;1312:161:0:-;778:5;;;;764:10;:19;756:44;;;;;;;1642:2:6;756:44:0;;;1624:21:6;1681:2;1661:18;;;1654:30;1720:14;1700:18;;;1693:42;1752:18;;756:44:0;1440:336:6;756:44:0;1392:5:::1;:16:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;1424:42:::1;::::0;1392:16;;1445:10:::1;::::0;1424:42:::1;::::0;1392:5;1424:42:::1;1312:161:::0;:::o;4351:276:3:-;4416:7;4439:22;;;4435:186;;-1:-1:-1;4486:21:3;;4351:276;-1:-1:-1;4351:276:3:o;4435:186::-;4545:65;;;;;4604:4;4545:65;;;160:74:6;4545:50:3;;;;;;133:18:6;;4545:65:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4538:72;4351:276;-1:-1:-1;;4351:276:3:o;1472:2873::-;1743:12;1769:22;;;1765:2574;;1956:1;1953;1950;1947;1939:6;1935:2;1928:5;1923:35;1912:46;;2086:7;2081:127;;2113:80;2148:2;2159:1;2163:29;2113:34;:80::i;:::-;1765:2574;;;2352:4;2346:11;2488:66;2483:3;2476:79;2600:42;2596:2;2592:51;2588:1;2583:3;2579:11;2572:72;2720:6;2715:2;2710:3;2706:12;2699:28;3649:2;3646:1;3642:2;3637:3;3634:1;3624:8;3617:5;3612:40;3141:16;3134:24;3128:2;3110:16;3107:24;3103:1;3099;3093:8;3090:15;3086:46;3083:76;2859:815;2828:846;;3752:1;3747:3;3740:14;3853:1;3846:4;3841:3;3837:14;3830:25;3956:1;3949:4;3944:3;3940:14;3933:25;;4125:7;4120:209;;4152:162;4224:8;4235:31;4268:28;4152:34;:162::i;:::-;1546:2799;1472:2873;;;:::o;3508:1663:2:-;3953:4;3947:11;3710:21;4094:33;;;4186:42;4163:66;;4156:4;4147:14;;4140:90;4330:66;4299:98;;4276:4;4267:14;;4243:168;4483:4;4476;4467:14;;4460:28;3919:2;3909;3891:16;3887:25;3883:34;;;3879:43;4569:4;4565:26;;4558:4;4549:14;;4542:50;4662:16;4655:4;4646:14;;4639:40;3710:21;;4755:16;-1:-1:-1;4745:4:2;4736:14;;4721:51;4869:4;4850:15;4844:4;4840:26;4835:3;4831:36;4824:50;5022:66;5003:17;4999:90;4964:15;4958:4;4954:26;4949:3;4945:36;4921:182;5138:15;5132:4;5128:26;5123:3;5116:39;245:154:6;331:42;324:5;320:54;313:5;310:65;300:93;;389:1;386;379:12;300:93;245:154;:::o;404:247::-;463:6;516:2;504:9;495:7;491:23;487:32;484:52;;;532:1;529;522:12;484:52;571:9;558:23;590:31;615:5;590:31;:::i;:::-;640:5;404:247;-1:-1:-1;;;404:247:6:o;656:779::-;779:6;787;795;848:2;836:9;827:7;823:23;819:32;816:52;;;864:1;861;854:12;816:52;904:9;891:23;937:18;929:6;926:30;923:50;;;969:1;966;959:12;923:50;992:22;;1045:4;1037:13;;1033:27;-1:-1:-1;1023:55:6;;1074:1;1071;1064:12;1023:55;1114:2;1101:16;1140:18;1132:6;1129:30;1126:50;;;1172:1;1169;1162:12;1126:50;1227:7;1220:4;1210:6;1207:1;1203:14;1199:2;1195:23;1191:34;1188:47;1185:67;;;1248:1;1245;1238:12;1185:67;1279:4;1271:13;;;;-1:-1:-1;1303:6:6;-1:-1:-1;1344:20:6;;1331:34;1374:31;1331:34;1374:31;:::i;:::-;1424:5;1414:15;;;656:779;;;;;:::o;1781:184::-;1833:77;1830:1;1823:88;1930:4;1927:1;1920:15;1954:4;1951:1;1944:15;2250:184;2320:6;2373:2;2361:9;2352:7;2348:23;2344:32;2341:52;;;2389:1;2386;2379:12;2341:52;-1:-1:-1;2412:16:6;;2250:184;-1:-1:-1;2250:184:6:o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220d7aaaac8fac923c3688a2499f02549639e68ab7c9bff12588a7d729c85c0c75364736f6c634300081d0033","offset":1937}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x7b2cd255cbbea7321bc3392c6781c42508114b48d513db9e15d45ebdf3912c91","blockNumber":"24028203","transactionIndex":"210","deployer":"0x2CF8e5b175aa29C1fDf0e9fe572735C78eacCE43"},"sources":{"src/TokenJar.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.29;\n\nimport {Currency} from \"v4-core/types/Currency.sol\";\nimport {Owned} from \"solmate/src/auth/Owned.sol\";\nimport {ITokenJar} from \"./interfaces/ITokenJar.sol\";\n\n/// @title TokenJar\n/// @notice A singular destination for protocol fees\n/// @dev Fees accumulate passively in this contract from external sources.\n///      Stored fees can be released by an authorized releaser contract.\n/// @custom:security-contact security@uniswap.org\ncontract TokenJar is Owned, ITokenJar {\n  /// @inheritdoc ITokenJar\n  address public releaser;\n\n  /// @notice Ensures only the releaser can call the release function\n  modifier onlyReleaser() {\n    require(msg.sender == releaser, Unauthorized());\n    _;\n  }\n\n  /// @dev creates an token jar where the deployer is the initial owner\n  /// during deployment, the deployer SHOULD set the releaser address and\n  /// transfer ownership\n  constructor() Owned(msg.sender) {}\n\n  /// @inheritdoc ITokenJar\n  function release(Currency[] calldata assets, address recipient) external onlyReleaser {\n    Currency asset;\n    uint256 amount;\n    for (uint256 i; i < assets.length; i++) {\n      asset = assets[i];\n      amount = asset.balanceOfSelf();\n      if (amount > 0) asset.transfer(recipient, amount);\n    }\n  }\n\n  /// @inheritdoc ITokenJar\n  function setReleaser(address _releaser) external onlyOwner {\n    releaser = _releaser;\n  }\n\n  receive() external payable {}\n}\n"},"lib/v4-core/src/types/Currency.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC20Minimal} from \"../interfaces/external/IERC20Minimal.sol\";\nimport {CustomRevert} from \"../libraries/CustomRevert.sol\";\n\ntype Currency is address;\n\nusing {greaterThan as >, lessThan as <, greaterThanOrEqualTo as >=, equals as ==} for Currency global;\nusing CurrencyLibrary for Currency global;\n\nfunction equals(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) == Currency.unwrap(other);\n}\n\nfunction greaterThan(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) > Currency.unwrap(other);\n}\n\nfunction lessThan(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) < Currency.unwrap(other);\n}\n\nfunction greaterThanOrEqualTo(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) >= Currency.unwrap(other);\n}\n\n/// @title CurrencyLibrary\n/// @dev This library allows for transferring and holding native tokens and ERC20 tokens\nlibrary CurrencyLibrary {\n    /// @notice Additional context for ERC-7751 wrapped error when a native transfer fails\n    error NativeTransferFailed();\n\n    /// @notice Additional context for ERC-7751 wrapped error when an ERC20 transfer fails\n    error ERC20TransferFailed();\n\n    /// @notice A constant to represent the native currency\n    Currency public constant ADDRESS_ZERO = Currency.wrap(address(0));\n\n    function transfer(Currency currency, address to, uint256 amount) internal {\n        // altered from https://github.com/transmissions11/solmate/blob/44a9963d4c78111f77caa0e65d677b8b46d6f2e6/src/utils/SafeTransferLib.sol\n        // modified custom error selectors\n\n        bool success;\n        if (currency.isAddressZero()) {\n            assembly (\"memory-safe\") {\n                // Transfer the ETH and revert if it fails.\n                success := call(gas(), to, amount, 0, 0, 0, 0)\n            }\n            // revert with NativeTransferFailed, containing the bubbled up error as an argument\n            if (!success) {\n                CustomRevert.bubbleUpAndRevertWith(to, bytes4(0), NativeTransferFailed.selector);\n            }\n        } else {\n            assembly (\"memory-safe\") {\n                // Get a pointer to some free memory.\n                let fmp := mload(0x40)\n\n                // Write the abi-encoded calldata into memory, beginning with the function selector.\n                mstore(fmp, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n                mstore(add(fmp, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the \"to\" argument.\n                mstore(add(fmp, 36), amount) // Append the \"amount\" argument. Masking not required as it's a full 32 byte type.\n\n                success :=\n                    and(\n                        // Set success to whether the call reverted, if not we check it either\n                        // returned exactly 1 (can't just be non-zero data), or had no return data.\n                        or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),\n                        // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.\n                        // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.\n                        // Counterintuitively, this call must be positioned second to the or() call in the\n                        // surrounding and() call or else returndatasize() will be zero during the computation.\n                        call(gas(), currency, 0, fmp, 68, 0, 32)\n                    )\n\n                // Now clean the memory we used\n                mstore(fmp, 0) // 4 byte `selector` and 28 bytes of `to` were stored here\n                mstore(add(fmp, 0x20), 0) // 4 bytes of `to` and 28 bytes of `amount` were stored here\n                mstore(add(fmp, 0x40), 0) // 4 bytes of `amount` were stored here\n            }\n            // revert with ERC20TransferFailed, containing the bubbled up error as an argument\n            if (!success) {\n                CustomRevert.bubbleUpAndRevertWith(\n                    Currency.unwrap(currency), IERC20Minimal.transfer.selector, ERC20TransferFailed.selector\n                );\n            }\n        }\n    }\n\n    function balanceOfSelf(Currency currency) internal view returns (uint256) {\n        if (currency.isAddressZero()) {\n            return address(this).balance;\n        } else {\n            return IERC20Minimal(Currency.unwrap(currency)).balanceOf(address(this));\n        }\n    }\n\n    function balanceOf(Currency currency, address owner) internal view returns (uint256) {\n        if (currency.isAddressZero()) {\n            return owner.balance;\n        } else {\n            return IERC20Minimal(Currency.unwrap(currency)).balanceOf(owner);\n        }\n    }\n\n    function isAddressZero(Currency currency) internal pure returns (bool) {\n        return Currency.unwrap(currency) == Currency.unwrap(ADDRESS_ZERO);\n    }\n\n    function toId(Currency currency) internal pure returns (uint256) {\n        return uint160(Currency.unwrap(currency));\n    }\n\n    // If the upper 12 bytes are non-zero, they will be zero-ed out\n    // Therefore, fromId() and toId() are not inverses of each other\n    function fromId(uint256 id) internal pure returns (Currency) {\n        return Currency.wrap(address(uint160(id)));\n    }\n}\n"},"lib/solmate/src/auth/Owned.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)\nabstract contract Owned {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event OwnershipTransferred(address indexed user, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                            OWNERSHIP STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    address public owner;\n\n    modifier onlyOwner() virtual {\n        require(msg.sender == owner, \"UNAUTHORIZED\");\n\n        _;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(address _owner) {\n        owner = _owner;\n\n        emit OwnershipTransferred(address(0), _owner);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                             OWNERSHIP LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        owner = newOwner;\n\n        emit OwnershipTransferred(msg.sender, newOwner);\n    }\n}\n"},"src/interfaces/ITokenJar.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.29;\n\nimport {Currency} from \"v4-core/types/Currency.sol\";\n\n/// @title Token Jar Interface\n/// @notice The interface for releasing assets from the contract\ninterface ITokenJar {\n  /// @notice Thrown when an unauthorized address attempts to call a restricted function\n  error Unauthorized();\n\n  /// @return Address of the current IReleaser\n  /// @dev The releaser has exclusive access to the `release()` function\n  function releaser() external view returns (address);\n\n  /// @notice Set the address of the IReleaser contract\n  /// @dev only callabe by `owner`\n  function setReleaser(address _releaser) external;\n\n  /// @notice Release assets to a specified recipient\n  /// @dev only callable by `releaser`\n  function release(Currency[] calldata assets, address recipient) external;\n}\n"},"lib/v4-core/src/interfaces/external/IERC20Minimal.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Minimal ERC20 interface for Uniswap\n/// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3\ninterface IERC20Minimal {\n    /// @notice Returns an account's balance in the token\n    /// @param account The account for which to look up the number of tokens it has, i.e. its balance\n    /// @return The number of tokens held by the account\n    function balanceOf(address account) external view returns (uint256);\n\n    /// @notice Transfers the amount of token from the `msg.sender` to the recipient\n    /// @param recipient The account that will receive the amount transferred\n    /// @param amount The number of tokens to send from the sender to the recipient\n    /// @return Returns true for a successful transfer, false for an unsuccessful transfer\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /// @notice Returns the current allowance given to a spender by an owner\n    /// @param owner The account of the token owner\n    /// @param spender The account of the token spender\n    /// @return The current allowance granted by `owner` to `spender`\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount`\n    /// @param spender The account which will be allowed to spend a given amount of the owners tokens\n    /// @param amount The amount of tokens allowed to be used by `spender`\n    /// @return Returns true for a successful approval, false for unsuccessful\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender`\n    /// @param sender The account from which the transfer will be initiated\n    /// @param recipient The recipient of the transfer\n    /// @param amount The amount of the transfer\n    /// @return Returns true for a successful transfer, false for unsuccessful\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n    /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`.\n    /// @param from The account from which the tokens were sent, i.e. the balance decreased\n    /// @param to The account to which the tokens were sent, i.e. the balance increased\n    /// @param value The amount of tokens that were transferred\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes.\n    /// @param owner The account that approved spending of its tokens\n    /// @param spender The account for which the spending allowance was modified\n    /// @param value The new allowance from the owner to the spender\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"},"lib/v4-core/src/libraries/CustomRevert.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Library for reverting with custom errors efficiently\n/// @notice Contains functions for reverting with custom errors with different argument types efficiently\n/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with\n/// `CustomError.selector.revertWith()`\n/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately\nlibrary CustomRevert {\n    /// @dev ERC-7751 error for wrapping bubbled up reverts\n    error WrappedError(address target, bytes4 selector, bytes reason, bytes details);\n\n    /// @dev Reverts with the selector of a custom error in the scratch space\n    function revertWith(bytes4 selector) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            revert(0, 0x04)\n        }\n    }\n\n    /// @dev Reverts with a custom error with an address argument in the scratch space\n    function revertWith(bytes4 selector, address addr) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with an int24 argument in the scratch space\n    function revertWith(bytes4 selector, int24 value) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, signextend(2, value))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with a uint160 argument in the scratch space\n    function revertWith(bytes4 selector, uint160 value) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, and(value, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two int24 arguments\n    function revertWith(bytes4 selector, int24 value1, int24 value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), signextend(2, value1))\n            mstore(add(fmp, 0x24), signextend(2, value2))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two uint160 arguments\n    function revertWith(bytes4 selector, uint160 value1, uint160 value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two address arguments\n    function revertWith(bytes4 selector, address value1, address value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error\n    /// @dev this method can be vulnerable to revert data bombs\n    function bubbleUpAndRevertWith(\n        address revertingContract,\n        bytes4 revertingFunctionSelector,\n        bytes4 additionalContext\n    ) internal pure {\n        bytes4 wrappedErrorSelector = WrappedError.selector;\n        assembly (\"memory-safe\") {\n            // Ensure the size of the revert data is a multiple of 32 bytes\n            let encodedDataSize := mul(div(add(returndatasize(), 31), 32), 32)\n\n            let fmp := mload(0x40)\n\n            // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason\n            mstore(fmp, wrappedErrorSelector)\n            mstore(add(fmp, 0x04), and(revertingContract, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(\n                add(fmp, 0x24),\n                and(revertingFunctionSelector, 0xffffffff00000000000000000000000000000000000000000000000000000000)\n            )\n            // offset revert reason\n            mstore(add(fmp, 0x44), 0x80)\n            // offset additional context\n            mstore(add(fmp, 0x64), add(0xa0, encodedDataSize))\n            // size revert reason\n            mstore(add(fmp, 0x84), returndatasize())\n            // revert reason\n            returndatacopy(add(fmp, 0xa4), 0, returndatasize())\n            // size additional context\n            mstore(add(fmp, add(0xa4, encodedDataSize)), 0x04)\n            // additional context\n            mstore(\n                add(fmp, add(0xc4, encodedDataSize)),\n                and(additionalContext, 0xffffffff00000000000000000000000000000000000000000000000000000000)\n            )\n            revert(fmp, add(0xe4, encodedDataSize))\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.29+commit.ab55807c","compilerSettings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":10000000,"enabled":true},"evmVersion":"cancun","remappings":["solmate/=lib/solmate/","@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/","eas-contracts/=lib/dao-signer/lib/eas-contracts/contracts/","scripts/libraries/Config.sol=lib/optimism/packages/contracts-bedrock/scripts/libraries/Config.sol","src/AgreementAnchorFactory.sol=lib/dao-signer/src/AgreementAnchorFactory.sol","src/AgreementAnchor.sol=lib/dao-signer/src/AgreementAnchor.sol","src/interfaces/IAgreementAnchorFactory.sol=lib/dao-signer/src/interfaces/IAgreementAnchorFactory.sol","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","BokkyPooBahsDateTimeLibrary/=lib/BokkyPooBahsDateTimeLibrary/","briefcase/=lib/briefcase/src/","dao-signer/=lib/dao-signer/","ds-test/=lib/solmate/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","hardhat/=lib/v4-core/node_modules/hardhat/","kontrol-cheatcodes/=lib/optimism/packages/contracts-bedrock/lib/kontrol-cheatcodes/src/","lib-keccak/=lib/optimism/packages/contracts-bedrock/lib/lib-keccak/contracts/","murky/=lib/murky/","openzeppelin-contracts-upgradeable/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","optimism/=lib/optimism/","safe-contracts/=lib/optimism/packages/contracts-bedrock/lib/safe-contracts/","solady-v0.0.245/=lib/optimism/packages/contracts-bedrock/lib/solady-v0.0.245/src/","solady/=lib/optimism/packages/contracts-bedrock/lib/solady/","v3-core/=lib/v3-core/","v4-core/=lib/v4-core/src/"]},"name":"TokenJar","fullyQualifiedName":"src/TokenJar.sol:TokenJar"},"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"release","type":"function","inputs":[{"name":"assets","type":"address[]","internalType":"Currency[]"},{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaser","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"setReleaser","type":"function","inputs":[{"name":"_releaser","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.29+commit.ab55807c"},"language":"Solidity","output":{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"Currency[]","name":"assets","type":"address[]"},{"internalType":"address","name":"recipient","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaser","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_releaser","type":"address"}],"name":"setReleaser","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"custom:security-contact":"security@uniswap.org","details":"Fees accumulate passively in this contract from external sources.      Stored fees can be released by an authorized releaser contract.","kind":"dev","methods":{"constructor":{"details":"creates an token jar where the deployer is the initial owner during deployment, the deployer SHOULD set the releaser address and transfer ownership"},"release(address[],address)":{"details":"only callable by `releaser`"},"setReleaser(address)":{"details":"only callabe by `owner`"}},"stateVariables":{"releaser":{"details":"The releaser has exclusive access to the `release()` function","return":"Address of the current IReleaser","returns":{"_0":"Address of the current IReleaser"}}},"title":"TokenJar","version":1},"userdoc":{"errors":{"Unauthorized()":[{"notice":"Thrown when an unauthorized address attempts to call a restricted function"}]},"kind":"user","methods":{"release(address[],address)":{"notice":"Release assets to a specified recipient"},"setReleaser(address)":{"notice":"Set the address of the IReleaser contract"}},"notice":"A singular destination for protocol fees","version":1}},"settings":{"compilationTarget":{"src/TokenJar.sol":"TokenJar"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":10000000},"remappings":[":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",":@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/",":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/",":BokkyPooBahsDateTimeLibrary/=lib/BokkyPooBahsDateTimeLibrary/",":briefcase/=lib/briefcase/src/",":dao-signer/=lib/dao-signer/",":ds-test/=lib/solmate/lib/ds-test/src/",":eas-contracts/=lib/dao-signer/lib/eas-contracts/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":hardhat/=lib/v4-core/node_modules/hardhat/",":kontrol-cheatcodes/=lib/optimism/packages/contracts-bedrock/lib/kontrol-cheatcodes/src/",":lib-keccak/=lib/optimism/packages/contracts-bedrock/lib/lib-keccak/contracts/",":murky/=lib/murky/",":openzeppelin-contracts-upgradeable/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-upgradeable/",":openzeppelin-contracts-v5/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-v5/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":optimism/=lib/optimism/",":safe-contracts/=lib/optimism/packages/contracts-bedrock/lib/safe-contracts/",":scripts/libraries/Config.sol=lib/optimism/packages/contracts-bedrock/scripts/libraries/Config.sol",":solady-v0.0.245/=lib/optimism/packages/contracts-bedrock/lib/solady-v0.0.245/src/",":solady/=lib/optimism/packages/contracts-bedrock/lib/solady/",":solmate/=lib/solmate/",":src/AgreementAnchor.sol=lib/dao-signer/src/AgreementAnchor.sol",":src/AgreementAnchorFactory.sol=lib/dao-signer/src/AgreementAnchorFactory.sol",":src/interfaces/IAgreementAnchorFactory.sol=lib/dao-signer/src/interfaces/IAgreementAnchorFactory.sol",":v3-core/=lib/v3-core/",":v4-core/=lib/v4-core/src/"]},"sources":{"lib/solmate/src/auth/Owned.sol":{"keccak256":"0xfedb27d14c508342c33eb067c9a02eabcdb0f9dcf93b04ded1001f580d12d0ea","license":"AGPL-3.0-only","urls":["bzz-raw://1ff52bbee698b9cf9e4574615e6550be0887ccf355f6571e23d6f25b332e79b4","dweb:/ipfs/QmVorA2apojVRStzS7h8aFccR3Uv32G6HVtBtFHZrE7YXx"]},"lib/v4-core/src/interfaces/external/IERC20Minimal.sol":{"keccak256":"0xeccadf1bf69ba2eb51f2fe4fa511bc7bb05bbd6b9f9a3cb8e5d83d9582613e0f","license":"MIT","urls":["bzz-raw://118757369892687b99ef46ce28d6861f62c098285bd7687a4f17f7e44e5f81de","dweb:/ipfs/QmUxqbYqQtcEwwFbb9e6BBMePEaSgN8C45v6RKubD4ib8d"]},"lib/v4-core/src/libraries/CustomRevert.sol":{"keccak256":"0x111ed3031b6990c80a93ae35dde6b6ac0b7e6af471388fdd7461e91edda9b7de","license":"MIT","urls":["bzz-raw://c9ea883c98d6ae1829160d0977bb5195761cfd5bc81692d0a941f45717f594cd","dweb:/ipfs/QmZPwxzaeMNv536wzrAMrMswu7vMHuqPVpjcqL3YvCMoxt"]},"lib/v4-core/src/types/Currency.sol":{"keccak256":"0x4a0b84b282577ff6f8acf13ec9f4d32dbb9348748b49611d00e68bee96609c93","license":"MIT","urls":["bzz-raw://45f9d62ab3d51b52957279e353853ba1547c3182c9a1e3d1846ada4a90263b01","dweb:/ipfs/QmS8NG84ccQS1yXVD8cv3eKX7J1UKxuJhbUfHTQR2opKF5"]},"src/TokenJar.sol":{"keccak256":"0x67bfde17ace741c9d6fc3817b420bf08497e500d934e2a2fe6b4455e2e4c8318","license":"AGPL-3.0-only","urls":["bzz-raw://3abb1910dcfba4e885150faf5cfe68dd0911b6bff3e8d96d4f4aae7987b0fbb1","dweb:/ipfs/QmaBMP589yYSDbRRY7EzoEFAftG9C1wSvXy5g4qNnrrSWE"]},"src/interfaces/ITokenJar.sol":{"keccak256":"0xc8b08ef19ea10b0da06d825507e032c9aa6e6399b28a68e1e7d67496dec69673","license":"AGPL-3.0-only","urls":["bzz-raw://f43228eafe2750c493ec0ebdaba04cc68c0c8593c97a65462208c278e9349622","dweb:/ipfs/Qmexgqm7bJnPGfrYryNKnDgCWMvMxUMoesbBsEKy2dVqxw"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":10,"label":"owner","offset":0,"contract":"src/TokenJar.sol:TokenJar"},{"slot":"1","type":"t_address","astId":555,"label":"releaser","offset":0,"contract":"src/TokenJar.sol:TokenJar"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","errors":{"Unauthorized()":[{"notice":"Thrown when an unauthorized address attempts to call a restricted function"}]},"notice":"A singular destination for protocol fees","methods":{"setReleaser(address)":{"notice":"Set the address of the IReleaser contract"},"release(address[],address)":{"notice":"Release assets to a specified recipient"}},"version":1},"devdoc":{"kind":"dev","title":"TokenJar","details":"Fees accumulate passively in this contract from external sources.      Stored fees can be released by an authorized releaser contract.","methods":{"constructor":{"details":"creates an token jar where the deployer is the initial owner during deployment, the deployer SHOULD set the releaser address and transfer ownership"},"setReleaser(address)":{"details":"only callabe by `owner`"},"release(address[],address)":{"details":"only callable by `releaser`"}},"version":1,"stateVariables":{"releaser":{"return":"Address of the current IReleaser","details":"The releaser has exclusive access to the `release()` function","returns":{"_0":"Address of the current IReleaser"}}},"custom:security-contact":"security@uniswap.org"},"sourceIds":{"src/TokenJar.sol":{"id":4},"src/interfaces/ITokenJar.sol":{"id":5},"lib/solmate/src/auth/Owned.sol":{"id":0},"lib/v4-core/src/types/Currency.sol":{"id":3},"lib/v4-core/src/libraries/CustomRevert.sol":{"id":2},"lib/v4-core/src/interfaces/external/IERC20Minimal.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"src/TokenJar.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.29;\n\nimport {Currency} from \"v4-core/types/Currency.sol\";\nimport {Owned} from \"solmate/src/auth/Owned.sol\";\nimport {ITokenJar} from \"./interfaces/ITokenJar.sol\";\n\n/// @title TokenJar\n/// @notice A singular destination for protocol fees\n/// @dev Fees accumulate passively in this contract from external sources.\n///      Stored fees can be released by an authorized releaser contract.\n/// @custom:security-contact security@uniswap.org\ncontract TokenJar is Owned, ITokenJar {\n  /// @inheritdoc ITokenJar\n  address public releaser;\n\n  /// @notice Ensures only the releaser can call the release function\n  modifier onlyReleaser() {\n    require(msg.sender == releaser, Unauthorized());\n    _;\n  }\n\n  /// @dev creates an token jar where the deployer is the initial owner\n  /// during deployment, the deployer SHOULD set the releaser address and\n  /// transfer ownership\n  constructor() Owned(msg.sender) {}\n\n  /// @inheritdoc ITokenJar\n  function release(Currency[] calldata assets, address recipient) external onlyReleaser {\n    Currency asset;\n    uint256 amount;\n    for (uint256 i; i < assets.length; i++) {\n      asset = assets[i];\n      amount = asset.balanceOfSelf();\n      if (amount > 0) asset.transfer(recipient, amount);\n    }\n  }\n\n  /// @inheritdoc ITokenJar\n  function setReleaser(address _releaser) external onlyOwner {\n    releaser = _releaser;\n  }\n\n  receive() external payable {}\n}\n"},"src/interfaces/ITokenJar.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity ^0.8.29;\n\nimport {Currency} from \"v4-core/types/Currency.sol\";\n\n/// @title Token Jar Interface\n/// @notice The interface for releasing assets from the contract\ninterface ITokenJar {\n  /// @notice Thrown when an unauthorized address attempts to call a restricted function\n  error Unauthorized();\n\n  /// @return Address of the current IReleaser\n  /// @dev The releaser has exclusive access to the `release()` function\n  function releaser() external view returns (address);\n\n  /// @notice Set the address of the IReleaser contract\n  /// @dev only callabe by `owner`\n  function setReleaser(address _releaser) external;\n\n  /// @notice Release assets to a specified recipient\n  /// @dev only callable by `releaser`\n  function release(Currency[] calldata assets, address recipient) external;\n}\n"},"lib/solmate/src/auth/Owned.sol":{"content":"// SPDX-License-Identifier: AGPL-3.0-only\npragma solidity >=0.8.0;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)\nabstract contract Owned {\n    /*//////////////////////////////////////////////////////////////\n                                 EVENTS\n    //////////////////////////////////////////////////////////////*/\n\n    event OwnershipTransferred(address indexed user, address indexed newOwner);\n\n    /*//////////////////////////////////////////////////////////////\n                            OWNERSHIP STORAGE\n    //////////////////////////////////////////////////////////////*/\n\n    address public owner;\n\n    modifier onlyOwner() virtual {\n        require(msg.sender == owner, \"UNAUTHORIZED\");\n\n        _;\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                               CONSTRUCTOR\n    //////////////////////////////////////////////////////////////*/\n\n    constructor(address _owner) {\n        owner = _owner;\n\n        emit OwnershipTransferred(address(0), _owner);\n    }\n\n    /*//////////////////////////////////////////////////////////////\n                             OWNERSHIP LOGIC\n    //////////////////////////////////////////////////////////////*/\n\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        owner = newOwner;\n\n        emit OwnershipTransferred(msg.sender, newOwner);\n    }\n}\n"},"lib/v4-core/src/types/Currency.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IERC20Minimal} from \"../interfaces/external/IERC20Minimal.sol\";\nimport {CustomRevert} from \"../libraries/CustomRevert.sol\";\n\ntype Currency is address;\n\nusing {greaterThan as >, lessThan as <, greaterThanOrEqualTo as >=, equals as ==} for Currency global;\nusing CurrencyLibrary for Currency global;\n\nfunction equals(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) == Currency.unwrap(other);\n}\n\nfunction greaterThan(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) > Currency.unwrap(other);\n}\n\nfunction lessThan(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) < Currency.unwrap(other);\n}\n\nfunction greaterThanOrEqualTo(Currency currency, Currency other) pure returns (bool) {\n    return Currency.unwrap(currency) >= Currency.unwrap(other);\n}\n\n/// @title CurrencyLibrary\n/// @dev This library allows for transferring and holding native tokens and ERC20 tokens\nlibrary CurrencyLibrary {\n    /// @notice Additional context for ERC-7751 wrapped error when a native transfer fails\n    error NativeTransferFailed();\n\n    /// @notice Additional context for ERC-7751 wrapped error when an ERC20 transfer fails\n    error ERC20TransferFailed();\n\n    /// @notice A constant to represent the native currency\n    Currency public constant ADDRESS_ZERO = Currency.wrap(address(0));\n\n    function transfer(Currency currency, address to, uint256 amount) internal {\n        // altered from https://github.com/transmissions11/solmate/blob/44a9963d4c78111f77caa0e65d677b8b46d6f2e6/src/utils/SafeTransferLib.sol\n        // modified custom error selectors\n\n        bool success;\n        if (currency.isAddressZero()) {\n            assembly (\"memory-safe\") {\n                // Transfer the ETH and revert if it fails.\n                success := call(gas(), to, amount, 0, 0, 0, 0)\n            }\n            // revert with NativeTransferFailed, containing the bubbled up error as an argument\n            if (!success) {\n                CustomRevert.bubbleUpAndRevertWith(to, bytes4(0), NativeTransferFailed.selector);\n            }\n        } else {\n            assembly (\"memory-safe\") {\n                // Get a pointer to some free memory.\n                let fmp := mload(0x40)\n\n                // Write the abi-encoded calldata into memory, beginning with the function selector.\n                mstore(fmp, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)\n                mstore(add(fmp, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the \"to\" argument.\n                mstore(add(fmp, 36), amount) // Append the \"amount\" argument. Masking not required as it's a full 32 byte type.\n\n                success :=\n                    and(\n                        // Set success to whether the call reverted, if not we check it either\n                        // returned exactly 1 (can't just be non-zero data), or had no return data.\n                        or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),\n                        // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.\n                        // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.\n                        // Counterintuitively, this call must be positioned second to the or() call in the\n                        // surrounding and() call or else returndatasize() will be zero during the computation.\n                        call(gas(), currency, 0, fmp, 68, 0, 32)\n                    )\n\n                // Now clean the memory we used\n                mstore(fmp, 0) // 4 byte `selector` and 28 bytes of `to` were stored here\n                mstore(add(fmp, 0x20), 0) // 4 bytes of `to` and 28 bytes of `amount` were stored here\n                mstore(add(fmp, 0x40), 0) // 4 bytes of `amount` were stored here\n            }\n            // revert with ERC20TransferFailed, containing the bubbled up error as an argument\n            if (!success) {\n                CustomRevert.bubbleUpAndRevertWith(\n                    Currency.unwrap(currency), IERC20Minimal.transfer.selector, ERC20TransferFailed.selector\n                );\n            }\n        }\n    }\n\n    function balanceOfSelf(Currency currency) internal view returns (uint256) {\n        if (currency.isAddressZero()) {\n            return address(this).balance;\n        } else {\n            return IERC20Minimal(Currency.unwrap(currency)).balanceOf(address(this));\n        }\n    }\n\n    function balanceOf(Currency currency, address owner) internal view returns (uint256) {\n        if (currency.isAddressZero()) {\n            return owner.balance;\n        } else {\n            return IERC20Minimal(Currency.unwrap(currency)).balanceOf(owner);\n        }\n    }\n\n    function isAddressZero(Currency currency) internal pure returns (bool) {\n        return Currency.unwrap(currency) == Currency.unwrap(ADDRESS_ZERO);\n    }\n\n    function toId(Currency currency) internal pure returns (uint256) {\n        return uint160(Currency.unwrap(currency));\n    }\n\n    // If the upper 12 bytes are non-zero, they will be zero-ed out\n    // Therefore, fromId() and toId() are not inverses of each other\n    function fromId(uint256 id) internal pure returns (Currency) {\n        return Currency.wrap(address(uint160(id)));\n    }\n}\n"},"lib/v4-core/src/libraries/CustomRevert.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Library for reverting with custom errors efficiently\n/// @notice Contains functions for reverting with custom errors with different argument types efficiently\n/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with\n/// `CustomError.selector.revertWith()`\n/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately\nlibrary CustomRevert {\n    /// @dev ERC-7751 error for wrapping bubbled up reverts\n    error WrappedError(address target, bytes4 selector, bytes reason, bytes details);\n\n    /// @dev Reverts with the selector of a custom error in the scratch space\n    function revertWith(bytes4 selector) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            revert(0, 0x04)\n        }\n    }\n\n    /// @dev Reverts with a custom error with an address argument in the scratch space\n    function revertWith(bytes4 selector, address addr) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, and(addr, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with an int24 argument in the scratch space\n    function revertWith(bytes4 selector, int24 value) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, signextend(2, value))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with a uint160 argument in the scratch space\n    function revertWith(bytes4 selector, uint160 value) internal pure {\n        assembly (\"memory-safe\") {\n            mstore(0, selector)\n            mstore(0x04, and(value, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(0, 0x24)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two int24 arguments\n    function revertWith(bytes4 selector, int24 value1, int24 value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), signextend(2, value1))\n            mstore(add(fmp, 0x24), signextend(2, value2))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two uint160 arguments\n    function revertWith(bytes4 selector, uint160 value1, uint160 value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @dev Reverts with a custom error with two address arguments\n    function revertWith(bytes4 selector, address value1, address value2) internal pure {\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(fmp, selector)\n            mstore(add(fmp, 0x04), and(value1, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(add(fmp, 0x24), and(value2, 0xffffffffffffffffffffffffffffffffffffffff))\n            revert(fmp, 0x44)\n        }\n    }\n\n    /// @notice bubble up the revert message returned by a call and revert with a wrapped ERC-7751 error\n    /// @dev this method can be vulnerable to revert data bombs\n    function bubbleUpAndRevertWith(\n        address revertingContract,\n        bytes4 revertingFunctionSelector,\n        bytes4 additionalContext\n    ) internal pure {\n        bytes4 wrappedErrorSelector = WrappedError.selector;\n        assembly (\"memory-safe\") {\n            // Ensure the size of the revert data is a multiple of 32 bytes\n            let encodedDataSize := mul(div(add(returndatasize(), 31), 32), 32)\n\n            let fmp := mload(0x40)\n\n            // Encode wrapped error selector, address, function selector, offset, additional context, size, revert reason\n            mstore(fmp, wrappedErrorSelector)\n            mstore(add(fmp, 0x04), and(revertingContract, 0xffffffffffffffffffffffffffffffffffffffff))\n            mstore(\n                add(fmp, 0x24),\n                and(revertingFunctionSelector, 0xffffffff00000000000000000000000000000000000000000000000000000000)\n            )\n            // offset revert reason\n            mstore(add(fmp, 0x44), 0x80)\n            // offset additional context\n            mstore(add(fmp, 0x64), add(0xa0, encodedDataSize))\n            // size revert reason\n            mstore(add(fmp, 0x84), returndatasize())\n            // revert reason\n            returndatacopy(add(fmp, 0xa4), 0, returndatasize())\n            // size additional context\n            mstore(add(fmp, add(0xa4, encodedDataSize)), 0x04)\n            // additional context\n            mstore(\n                add(fmp, add(0xc4, encodedDataSize)),\n                and(additionalContext, 0xffffffff00000000000000000000000000000000000000000000000000000000)\n            )\n            revert(fmp, add(0xe4, encodedDataSize))\n        }\n    }\n}\n"},"lib/v4-core/src/interfaces/external/IERC20Minimal.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @title Minimal ERC20 interface for Uniswap\n/// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3\ninterface IERC20Minimal {\n    /// @notice Returns an account's balance in the token\n    /// @param account The account for which to look up the number of tokens it has, i.e. its balance\n    /// @return The number of tokens held by the account\n    function balanceOf(address account) external view returns (uint256);\n\n    /// @notice Transfers the amount of token from the `msg.sender` to the recipient\n    /// @param recipient The account that will receive the amount transferred\n    /// @param amount The number of tokens to send from the sender to the recipient\n    /// @return Returns true for a successful transfer, false for an unsuccessful transfer\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /// @notice Returns the current allowance given to a spender by an owner\n    /// @param owner The account of the token owner\n    /// @param spender The account of the token spender\n    /// @return The current allowance granted by `owner` to `spender`\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount`\n    /// @param spender The account which will be allowed to spend a given amount of the owners tokens\n    /// @param amount The amount of tokens allowed to be used by `spender`\n    /// @return Returns true for a successful approval, false for unsuccessful\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender`\n    /// @param sender The account from which the transfer will be initiated\n    /// @param recipient The recipient of the transfer\n    /// @param amount The amount of the transfer\n    /// @return Returns true for a successful transfer, false for unsuccessful\n    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\n\n    /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`.\n    /// @param from The account from which the tokens were sent, i.e. the balance decreased\n    /// @param to The account to which the tokens were sent, i.e. the balance increased\n    /// @param value The amount of tokens that were transferred\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes.\n    /// @param owner The account that approved spending of its tokens\n    /// @param spender The account for which the spending allowance was modified\n    /// @param value The new allowance from the owner to the spender\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"}},"language":"Solidity","settings":{"viaIR":false,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":10000000,"enabled":true},"evmVersion":"cancun","remappings":["solmate/=lib/solmate/","@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/","eas-contracts/=lib/dao-signer/lib/eas-contracts/contracts/","scripts/libraries/Config.sol=lib/optimism/packages/contracts-bedrock/scripts/libraries/Config.sol","src/AgreementAnchorFactory.sol=lib/dao-signer/src/AgreementAnchorFactory.sol","src/AgreementAnchor.sol=lib/dao-signer/src/AgreementAnchor.sol","src/interfaces/IAgreementAnchorFactory.sol=lib/dao-signer/src/interfaces/IAgreementAnchorFactory.sol","@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","BokkyPooBahsDateTimeLibrary/=lib/BokkyPooBahsDateTimeLibrary/","briefcase/=lib/briefcase/src/","dao-signer/=lib/dao-signer/","ds-test/=lib/solmate/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/","hardhat/=lib/v4-core/node_modules/hardhat/","kontrol-cheatcodes/=lib/optimism/packages/contracts-bedrock/lib/kontrol-cheatcodes/src/","lib-keccak/=lib/optimism/packages/contracts-bedrock/lib/lib-keccak/contracts/","murky/=lib/murky/","openzeppelin-contracts-upgradeable/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-upgradeable/","openzeppelin-contracts-v5/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-v5/","openzeppelin-contracts/=lib/openzeppelin-contracts/","optimism/=lib/optimism/","safe-contracts/=lib/optimism/packages/contracts-bedrock/lib/safe-contracts/","solady-v0.0.245/=lib/optimism/packages/contracts-bedrock/lib/solady-v0.0.245/src/","solady/=lib/optimism/packages/contracts-bedrock/lib/solady/","v3-core/=lib/v3-core/","v4-core/=lib/v4-core/src/"]}},"stdJsonOutput":{"sources":{"src/TokenJar.sol":{"id":4},"src/interfaces/ITokenJar.sol":{"id":5},"lib/solmate/src/auth/Owned.sol":{"id":0},"lib/v4-core/src/types/Currency.sol":{"id":3},"lib/v4-core/src/libraries/CustomRevert.sol":{"id":2},"lib/v4-core/src/interfaces/external/IERC20Minimal.sol":{"id":1}},"contracts":{"src/TokenJar.sol":{"TokenJar":{"abi":[{"type":"constructor","inputs":[],"stateMutability":"nonpayable"},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"user","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"release","type":"function","inputs":[{"name":"assets","type":"address[]","internalType":"Currency[]"},{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"releaser","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"setReleaser","type":"function","inputs":[{"name":"_releaser","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.29+commit.ab55807c\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"user\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"Currency[]\",\"name\":\"assets\",\"type\":\"address[]\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"release\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"releaser\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_releaser\",\"type\":\"address\"}],\"name\":\"setReleaser\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"custom:security-contact\":\"security@uniswap.org\",\"details\":\"Fees accumulate passively in this contract from external sources.      Stored fees can be released by an authorized releaser contract.\",\"kind\":\"dev\",\"methods\":{\"constructor\":{\"details\":\"creates an token jar where the deployer is the initial owner during deployment, the deployer SHOULD set the releaser address and transfer ownership\"},\"release(address[],address)\":{\"details\":\"only callable by `releaser`\"},\"setReleaser(address)\":{\"details\":\"only callabe by `owner`\"}},\"stateVariables\":{\"releaser\":{\"details\":\"The releaser has exclusive access to the `release()` function\",\"return\":\"Address of the current IReleaser\",\"returns\":{\"_0\":\"Address of the current IReleaser\"}}},\"title\":\"TokenJar\",\"version\":1},\"userdoc\":{\"errors\":{\"Unauthorized()\":[{\"notice\":\"Thrown when an unauthorized address attempts to call a restricted function\"}]},\"kind\":\"user\",\"methods\":{\"release(address[],address)\":{\"notice\":\"Release assets to a specified recipient\"},\"setReleaser(address)\":{\"notice\":\"Set the address of the IReleaser contract\"}},\"notice\":\"A singular destination for protocol fees\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/TokenJar.sol\":\"TokenJar\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":10000000},\"remappings\":[\":@ensdomains/=lib/v4-core/node_modules/@ensdomains/\",\":@eth-optimism-bedrock/=lib/optimism/packages/contracts-bedrock/\",\":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\":BokkyPooBahsDateTimeLibrary/=lib/BokkyPooBahsDateTimeLibrary/\",\":briefcase/=lib/briefcase/src/\",\":dao-signer/=lib/dao-signer/\",\":ds-test/=lib/solmate/lib/ds-test/src/\",\":eas-contracts/=lib/dao-signer/lib/eas-contracts/contracts/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":hardhat/=lib/v4-core/node_modules/hardhat/\",\":kontrol-cheatcodes/=lib/optimism/packages/contracts-bedrock/lib/kontrol-cheatcodes/src/\",\":lib-keccak/=lib/optimism/packages/contracts-bedrock/lib/lib-keccak/contracts/\",\":murky/=lib/murky/\",\":openzeppelin-contracts-upgradeable/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-upgradeable/\",\":openzeppelin-contracts-v5/=lib/optimism/packages/contracts-bedrock/lib/openzeppelin-contracts-v5/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":optimism/=lib/optimism/\",\":safe-contracts/=lib/optimism/packages/contracts-bedrock/lib/safe-contracts/\",\":scripts/libraries/Config.sol=lib/optimism/packages/contracts-bedrock/scripts/libraries/Config.sol\",\":solady-v0.0.245/=lib/optimism/packages/contracts-bedrock/lib/solady-v0.0.245/src/\",\":solady/=lib/optimism/packages/contracts-bedrock/lib/solady/\",\":solmate/=lib/solmate/\",\":src/AgreementAnchor.sol=lib/dao-signer/src/AgreementAnchor.sol\",\":src/AgreementAnchorFactory.sol=lib/dao-signer/src/AgreementAnchorFactory.sol\",\":src/interfaces/IAgreementAnchorFactory.sol=lib/dao-signer/src/interfaces/IAgreementAnchorFactory.sol\",\":v3-core/=lib/v3-core/\",\":v4-core/=lib/v4-core/src/\"]},\"sources\":{\"lib/solmate/src/auth/Owned.sol\":{\"keccak256\":\"0xfedb27d14c508342c33eb067c9a02eabcdb0f9dcf93b04ded1001f580d12d0ea\",\"license\":\"AGPL-3.0-only\",\"urls\":[\"bzz-raw://1ff52bbee698b9cf9e4574615e6550be0887ccf355f6571e23d6f25b332e79b4\",\"dweb:/ipfs/QmVorA2apojVRStzS7h8aFccR3Uv32G6HVtBtFHZrE7YXx\"]},\"lib/v4-core/src/interfaces/external/IERC20Minimal.sol\":{\"keccak256\":\"0xeccadf1bf69ba2eb51f2fe4fa511bc7bb05bbd6b9f9a3cb8e5d83d9582613e0f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://118757369892687b99ef46ce28d6861f62c098285bd7687a4f17f7e44e5f81de\",\"dweb:/ipfs/QmUxqbYqQtcEwwFbb9e6BBMePEaSgN8C45v6RKubD4ib8d\"]},\"lib/v4-core/src/libraries/CustomRevert.sol\":{\"keccak256\":\"0x111ed3031b6990c80a93ae35dde6b6ac0b7e6af471388fdd7461e91edda9b7de\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c9ea883c98d6ae1829160d0977bb5195761cfd5bc81692d0a941f45717f594cd\",\"dweb:/ipfs/QmZPwxzaeMNv536wzrAMrMswu7vMHuqPVpjcqL3YvCMoxt\"]},\"lib/v4-core/src/types/Currency.sol\":{\"keccak256\":\"0x4a0b84b282577ff6f8acf13ec9f4d32dbb9348748b49611d00e68bee96609c93\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://45f9d62ab3d51b52957279e353853ba1547c3182c9a1e3d1846ada4a90263b01\",\"dweb:/ipfs/QmS8NG84ccQS1yXVD8cv3eKX7J1UKxuJhbUfHTQR2opKF5\"]},\"src/TokenJar.sol\":{\"keccak256\":\"0x67bfde17ace741c9d6fc3817b420bf08497e500d934e2a2fe6b4455e2e4c8318\",\"license\":\"AGPL-3.0-only\",\"urls\":[\"bzz-raw://3abb1910dcfba4e885150faf5cfe68dd0911b6bff3e8d96d4f4aae7987b0fbb1\",\"dweb:/ipfs/QmaBMP589yYSDbRRY7EzoEFAftG9C1wSvXy5g4qNnrrSWE\"]},\"src/interfaces/ITokenJar.sol\":{\"keccak256\":\"0xc8b08ef19ea10b0da06d825507e032c9aa6e6399b28a68e1e7d67496dec69673\",\"license\":\"AGPL-3.0-only\",\"urls\":[\"bzz-raw://f43228eafe2750c493ec0ebdaba04cc68c0c8593c97a65462208c278e9349622\",\"dweb:/ipfs/Qmexgqm7bJnPGfrYryNKnDgCWMvMxUMoesbBsEKy2dVqxw\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"Unauthorized()":[{"notice":"Thrown when an unauthorized address attempts to call a restricted function"}]},"notice":"A singular destination for protocol fees","methods":{"setReleaser(address)":{"notice":"Set the address of the IReleaser contract"},"release(address[],address)":{"notice":"Release assets to a specified recipient"}},"version":1},"devdoc":{"kind":"dev","title":"TokenJar","details":"Fees accumulate passively in this contract from external sources.      Stored fees can be released by an authorized releaser contract.","methods":{"constructor":{"details":"creates an token jar where the deployer is the initial owner during deployment, the deployer SHOULD set the releaser address and transfer ownership"},"setReleaser(address)":{"details":"only callabe by `owner`"},"release(address[],address)":{"details":"only callable by `releaser`"}},"version":1,"stateVariables":{"releaser":{"return":"Address of the current IReleaser","details":"The releaser has exclusive access to the `release()` function","returns":{"_0":"Address of the current IReleaser"}}},"custom:security-contact":"security@uniswap.org"},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"}},"storage":[{"slot":"0","type":"t_address","astId":10,"label":"owner","offset":0,"contract":"src/TokenJar.sol:TokenJar"},{"slot":"1","type":"t_address","astId":555,"label":"releaser","offset":0,"contract":"src/TokenJar.sol:TokenJar"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"497:958:4:-:0;;;929:34;;;;;;;;;-1:-1:-1;1045:5:0;:14;;-1:-1:-1;;;;;;1045:14:0;949:10:4;1045:14:0;;;;;1075:40;;949:10:4;;;;1075:40:0;;1045:5;;1075:40;1007:115;497:958:4;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"497:958:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;567:23;;;;;;;;;;-1:-1:-1;567:23:4;;;;;;;;;;;190:42:6;178:55;;;160:74;;148:2;133:18;567:23:4;;;;;;;1330:90;;;;;;;;;;-1:-1:-1;1330:90:4;;;;;:::i;:::-;;:::i;:::-;;690:20:0;;;;;;;;;;-1:-1:-1;690:20:0;;;;;;;;995:303:4;;;;;;;;;;-1:-1:-1;995:303:4;;;;;:::i;:::-;;:::i;1312:161:0:-;;;;;;;;;;-1:-1:-1;1312:161:0;;;;;:::i;:::-;;:::i;1330:90:4:-;778:5:0;;;;764:10;:19;756:44;;;;;;;1642:2:6;756:44:0;;;1624:21:6;1681:2;1661:18;;;1654:30;1720:14;1700:18;;;1693:42;1752:18;;756:44:0;;;;;;;;;1395:8:4::1;:20:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;1330:90::o;995:303::-;717:8;;;;703:10;:22;695:47;;;;;;;;;;;;;;;;;1087:14:::1;1107;1132:9;1127:167;1143:17:::0;;::::1;1127:167;;;1183:6;;1190:1;1183:9;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;1175:17;;1209:21;:5;:19;;;:21::i;:::-;1200:30:::0;-1:-1:-1;1242:10:4;;1238:49:::1;;1254:33;:14;::::0;::::1;1269:9:::0;1280:6;1254:14:::1;:33::i;:::-;1162:3;;1127:167;;;;1081:217;;995:303:::0;;;:::o;1312:161:0:-;778:5;;;;764:10;:19;756:44;;;;;;;1642:2:6;756:44:0;;;1624:21:6;1681:2;1661:18;;;1654:30;1720:14;1700:18;;;1693:42;1752:18;;756:44:0;1440:336:6;756:44:0;1392:5:::1;:16:::0;;;::::1;;::::0;::::1;::::0;;::::1;::::0;;1424:42:::1;::::0;1392:16;;1445:10:::1;::::0;1424:42:::1;::::0;1392:5;1424:42:::1;1312:161:::0;:::o;4351:276:3:-;4416:7;4439:22;;;4435:186;;-1:-1:-1;4486:21:3;;4351:276;-1:-1:-1;4351:276:3:o;4435:186::-;4545:65;;;;;4604:4;4545:65;;;160:74:6;4545:50:3;;;;;;133:18:6;;4545:65:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4538:72;4351:276;-1:-1:-1;;4351:276:3:o;1472:2873::-;1743:12;1769:22;;;1765:2574;;1956:1;1953;1950;1947;1939:6;1935:2;1928:5;1923:35;1912:46;;2086:7;2081:127;;2113:80;2148:2;2159:1;2163:29;2113:34;:80::i;:::-;1765:2574;;;2352:4;2346:11;2488:66;2483:3;2476:79;2600:42;2596:2;2592:51;2588:1;2583:3;2579:11;2572:72;2720:6;2715:2;2710:3;2706:12;2699:28;3649:2;3646:1;3642:2;3637:3;3634:1;3624:8;3617:5;3612:40;3141:16;3134:24;3128:2;3110:16;3107:24;3103:1;3099;3093:8;3090:15;3086:46;3083:76;2859:815;2828:846;;3752:1;3747:3;3740:14;3853:1;3846:4;3841:3;3837:14;3830:25;3956:1;3949:4;3944:3;3940:14;3933:25;;4125:7;4120:209;;4152:162;4224:8;4235:31;4268:28;4152:34;:162::i;:::-;1546:2799;1472:2873;;;:::o;3508:1663:2:-;3953:4;3947:11;3710:21;4094:33;;;4186:42;4163:66;;4156:4;4147:14;;4140:90;4330:66;4299:98;;4276:4;4267:14;;4243:168;4483:4;4476;4467:14;;4460:28;3919:2;3909;3891:16;3887:25;3883:34;;;3879:43;4569:4;4565:26;;4558:4;4549:14;;4542:50;4662:16;4655:4;4646:14;;4639:40;3710:21;;4755:16;-1:-1:-1;4745:4:2;4736:14;;4721:51;4869:4;4850:15;4844:4;4840:26;4835:3;4831:36;4824:50;5022:66;5003:17;4999:90;4964:15;4958:4;4954:26;4949:3;4945:36;4921:182;5138:15;5132:4;5128:26;5123:3;5116:39;245:154:6;331:42;324:5;320:54;313:5;310:65;300:93;;389:1;386;379:12;300:93;245:154;:::o;404:247::-;463:6;516:2;504:9;495:7;491:23;487:32;484:52;;;532:1;529;522:12;484:52;571:9;558:23;590:31;615:5;590:31;:::i;:::-;640:5;404:247;-1:-1:-1;;;404:247:6:o;656:779::-;779:6;787;795;848:2;836:9;827:7;823:23;819:32;816:52;;;864:1;861;854:12;816:52;904:9;891:23;937:18;929:6;926:30;923:50;;;969:1;966;959:12;923:50;992:22;;1045:4;1037:13;;1033:27;-1:-1:-1;1023:55:6;;1074:1;1071;1064:12;1023:55;1114:2;1101:16;1140:18;1132:6;1129:30;1126:50;;;1172:1;1169;1162:12;1126:50;1227:7;1220:4;1210:6;1207:1;1203:14;1199:2;1195:23;1191:34;1188:47;1185:67;;;1248:1;1245;1238:12;1185:67;1279:4;1271:13;;;;-1:-1:-1;1303:6:6;-1:-1:-1;1344:20:6;;1331:34;1374:31;1331:34;1374:31;:::i;:::-;1424:5;1414:15;;;656:779;;;;;:::o;1781:184::-;1833:77;1830:1;1823:88;1930:4;1927:1;1920:15;1954:4;1951:1;1944:15;2250:184;2320:6;2373:2;2361:9;2352:7;2348:23;2344:32;2341:52;;;2389:1;2386;2379:12;2341:52;-1:-1:-1;2412:16:6;;2250:184;-1:-1:-1;2250:184:6:o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"release(address[],address)","signatureHash4":"0xa7d092b2","signatureHash32":"0xa7d092b200e36e5048f32136da67ac2ace223c650bad41287785f4aa4e5fd190"},{"signature":"releaser()","signatureHash4":"0x02691bcb","signatureHash32":"0x02691bcb9bd68dd187954838f2f3f9529204eecadb676fbdf1a188be219594e8"},{"signature":"setReleaser(address)","signatureHash4":"0x2fc2f907","signatureHash32":"0x2fc2f907e5048ad5e8946889ef70716bea71c7e5cbdccc3c76053abb405f4ab9"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0xf38521f130fcCF29dB1961597bc5d2B60F995f85"}