{"matchId":"47533023","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-09-08T16:11:16Z","creationBytecode":{"onchainBytecode":"0x6080806040523460395760017f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f005561078c908161003e8239f35b5f80fdfe60806040526004361015610011575f80fd5b5f3560e01c806309ad4dd9146102015780631698755f146101d257806332f289cf14610187578063379607f5146101615780634e71d92d1461011a57806370a08231146100e3578063d5d44d80146100c55763f59e38b714610071575f80fd5b346100c15760403660031901126100c15761008a610249565b61009261025f565b6001600160a01b039182165f908152600160209081526040808320949093168252928352819020549051908152f35b5f80fd5b60203660031901126100c1576100e16100dc610249565b6104bd565b005b346100c15760203660031901126100c1576001600160a01b03610104610249565b165f525f602052602060405f2054604051908152f35b346100c1575f3660031901126100c15761013261051c565b335f525f602052602061014860405f2054610669565b60015f5160206107375f395f51905f5255604051908152f35b346100c15760203660031901126100c15761017a61051c565b6020610148600435610669565b346100c15760203660031901126100c15760206101486101a5610249565b6101ad61051c565b335f9081526001845260408082206001600160a01b0384168352855290205490610554565b346100c15760403660031901126100c15760206101486101f0610249565b6101f861051c565b60243590610554565b346100c15760603660031901126100c15761023661021d610249565b61022561025f565b61022d61051c565b604435916102d9565b60015f5160206107375f395f51905f5255005b600435906001600160a01b03821682036100c157565b602435906001600160a01b03821682036100c157565b90601f8019910116810190811067ffffffffffffffff82111761029757604052565b634e487b7160e01b5f52604160045260245ffd5b919082039182116102b857565b634e487b7160e01b5f52601160045260245ffd5b919082018092116102b857565b6001600160a01b03169190821580156104ac575b61049d5781156103f5576040516370a0823160e01b81523060048201526001600160a01b03919091169190602081602481865afa90811561042e575f9161046b575b50604051916323b872dd60e01b5f52336004523060245260445260205f60648180875af160015f511481161561044c575b826040525f60605215610439576370a0823160e01b8252306004830152602082602481865afa801561042e575f906103fa575b61039d92506102ab565b9182156103f557805f52600160205260405f20825f5260205260405f206103c58482546102cc565b90556040519283527f5d104c62f50449fadfe6f4013c8f36588d32737f94b5ac9b83ddad33b3e1ffdf60203394a4565b505050565b506020823d602011610426575b8161041460209383610275565b810103126100c15761039d9151610393565b3d9150610407565b6040513d5f823e3d90fd5b82635274afe760e01b5f5260045260245ffd5b600181151661046257833b15153d151616610360565b823d5f823e3d90fd5b90506020813d602011610495575b8161048660209383610275565b810103126100c157515f61032f565b3d9150610479565b63d92e233d60e01b5f5260045ffd5b506001600160a01b038116156102ed565b6001600160a01b0316801561049d57341561051957805f525f60205260405f206104e83482546102cc565b9055604051903482527f4e45da441832cf53bdaa69235704fc0575e68210f459ee1562911024b12967d560203393a3565b50565b60025f5160206107375f395f51905f5254146105455760025f5160206107375f395f51905f5255565b633ee5aeb560e01b5f5260045ffd5b811561065a57335f52600160205260405f2060018060a01b0382165f5260205260405f2054808311610644578261058a916102ab565b335f52600160205260405f2060018060a01b0383165f5260205260405f205560018060a01b031660405163a9059cbb60e01b5f52336004528260245260205f60448180865af160015f5114811615610625575b8160405215610612578281527fdbc1ea3a8459e4c7e11fb385b52bbb5cc8c8ab85eec5d883ac9aa78c171f514160203392a390565b50635274afe760e01b5f5260045260245ffd5b600181151661063b57823b15153d1516166105dd565b503d5f823e3d90fd5b8263cf47918160e01b5f5260045260245260445ffd5b636165515360e11b5f5260045ffd5b801561065a57335f525f60205260405f2054808211610720578161068c916102ab565b335f525f60205260405f20555f80808084335af13d1561071b573d67ffffffffffffffff811161029757604051906106ce601f8201601f191660200183610275565b81525f60203d92013e5b1561070c576040518181527fd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a60203392a290565b6312171d8360e31b5f5260045ffd5b6106d8565b9063cf47918160e01b5f5260045260245260445ffdfe9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00a2646970667358221220dbbc16195d46dd822a5bbc7c7a2c8ac6b3a2c13959882c7f071ff2c011021a2464736f6c63430008230033","recompiledBytecode":"0x6080806040523460395760017f9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f005561078c908161003e8239f35b5f80fdfe60806040526004361015610011575f80fd5b5f3560e01c806309ad4dd9146102015780631698755f146101d257806332f289cf14610187578063379607f5146101615780634e71d92d1461011a57806370a08231146100e3578063d5d44d80146100c55763f59e38b714610071575f80fd5b346100c15760403660031901126100c15761008a610249565b61009261025f565b6001600160a01b039182165f908152600160209081526040808320949093168252928352819020549051908152f35b5f80fd5b60203660031901126100c1576100e16100dc610249565b6104bd565b005b346100c15760203660031901126100c1576001600160a01b03610104610249565b165f525f602052602060405f2054604051908152f35b346100c1575f3660031901126100c15761013261051c565b335f525f602052602061014860405f2054610669565b60015f5160206107375f395f51905f5255604051908152f35b346100c15760203660031901126100c15761017a61051c565b6020610148600435610669565b346100c15760203660031901126100c15760206101486101a5610249565b6101ad61051c565b335f9081526001845260408082206001600160a01b0384168352855290205490610554565b346100c15760403660031901126100c15760206101486101f0610249565b6101f861051c565b60243590610554565b346100c15760603660031901126100c15761023661021d610249565b61022561025f565b61022d61051c565b604435916102d9565b60015f5160206107375f395f51905f5255005b600435906001600160a01b03821682036100c157565b602435906001600160a01b03821682036100c157565b90601f8019910116810190811067ffffffffffffffff82111761029757604052565b634e487b7160e01b5f52604160045260245ffd5b919082039182116102b857565b634e487b7160e01b5f52601160045260245ffd5b919082018092116102b857565b6001600160a01b03169190821580156104ac575b61049d5781156103f5576040516370a0823160e01b81523060048201526001600160a01b03919091169190602081602481865afa90811561042e575f9161046b575b50604051916323b872dd60e01b5f52336004523060245260445260205f60648180875af160015f511481161561044c575b826040525f60605215610439576370a0823160e01b8252306004830152602082602481865afa801561042e575f906103fa575b61039d92506102ab565b9182156103f557805f52600160205260405f20825f5260205260405f206103c58482546102cc565b90556040519283527f5d104c62f50449fadfe6f4013c8f36588d32737f94b5ac9b83ddad33b3e1ffdf60203394a4565b505050565b506020823d602011610426575b8161041460209383610275565b810103126100c15761039d9151610393565b3d9150610407565b6040513d5f823e3d90fd5b82635274afe760e01b5f5260045260245ffd5b600181151661046257833b15153d151616610360565b823d5f823e3d90fd5b90506020813d602011610495575b8161048660209383610275565b810103126100c157515f61032f565b3d9150610479565b63d92e233d60e01b5f5260045ffd5b506001600160a01b038116156102ed565b6001600160a01b0316801561049d57341561051957805f525f60205260405f206104e83482546102cc565b9055604051903482527f4e45da441832cf53bdaa69235704fc0575e68210f459ee1562911024b12967d560203393a3565b50565b60025f5160206107375f395f51905f5254146105455760025f5160206107375f395f51905f5255565b633ee5aeb560e01b5f5260045ffd5b811561065a57335f52600160205260405f2060018060a01b0382165f5260205260405f2054808311610644578261058a916102ab565b335f52600160205260405f2060018060a01b0383165f5260205260405f205560018060a01b031660405163a9059cbb60e01b5f52336004528260245260205f60448180865af160015f5114811615610625575b8160405215610612578281527fdbc1ea3a8459e4c7e11fb385b52bbb5cc8c8ab85eec5d883ac9aa78c171f514160203392a390565b50635274afe760e01b5f5260045260245ffd5b600181151661063b57823b15153d1516166105dd565b503d5f823e3d90fd5b8263cf47918160e01b5f5260045260245260445ffd5b636165515360e11b5f5260045ffd5b801561065a57335f525f60205260405f2054808211610720578161068c916102ab565b335f525f60205260405f20555f80808084335af13d1561071b573d67ffffffffffffffff811161029757604051906106ce601f8201601f191660200183610275565b81525f60203d92013e5b1561070c576040518181527fd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a60203392a290565b6312171d8360e31b5f5260045ffd5b6106d8565b9063cf47918160e01b5f5260045260245260445ffdfe9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00a2646970667358221220dbbc16195d46dd822a5bbc7c7a2c8ac6b3a2c13959882c7f071ff2c011021a2464736f6c63430008230033","sourceMap":"885:5467:20:-:0;;;;;;;2365:1:13;1505:66;2365:1;885:5467:20;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220dbbc16195d46dd822a5bbc7c7a2c8ac6b3a2c13959882c7f071ff2c011021a2464736f6c63430008230033","offset":1941}},"transformations":[],"transformationValues":{}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"885:5467:20:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;885:5467:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;-1:-1:-1;;885:5467:20;;;;-1:-1:-1;;;;;885:5467:20;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;2989:103:13;;:::i;:::-;3522:10:20;885:5467;;;;;;3505:29;885:5467;;;;3505:29;:::i;:::-;2365:1:13;-1:-1:-1;;;;;;;;;;;885:5467:20;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;2989:103:13;;:::i;:::-;885:5467:20;3730:14;885:5467;;3730:14;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;;3948:53;885:5467;;:::i;:::-;2989:103:13;;:::i;:::-;3982:10:20;885:5467;;;;3967:14;885:5467;;;;;;-1:-1:-1;;;;;885:5467:20;;;;;;;;;;3948:53;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;;4765:26;885:5467;;:::i;:::-;2989:103:13;;:::i;:::-;885:5467:20;;4765:26;;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;3054:1:13;885:5467:20;;:::i;:::-;;;:::i;:::-;2989:103:13;;:::i;:::-;885:5467:20;;3054:1:13;;:::i;:::-;885:5467:20;-1:-1:-1;;;;;;;;;;;885:5467:20;;;;;;-1:-1:-1;;;;;885:5467:20;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;885:5467:20;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;885:5467:20;;;;;-1:-1:-1;885:5467:20;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;2724:602::-;-1:-1:-1;;;;;885:5467:20;;2724:602;2831:23;;:46;;;;2724:602;2827:72;;2913:11;;2909:24;;885:5467;;-1:-1:-1;;;2966:38:20;;2998:4;2966:38;;;885:5467;-1:-1:-1;;;;;885:5467:20;;;;;;;;2966:38;885:5467;;2966:38;;;;;;;2852:1;2966:38;;;2724:602;1767:47:10;885:5467:20;10404:1148:10;10365:28;;;;2852:1:20;10404:1148:10;3045:10:20;2966:38;10404:1148:10;2998:4:20;2966:38;10404:1148:10;;;885:5467:20;2852:1;10404:1148:10;;;;;;1809:4;2852:1:20;10404:1148:10;;;;;;;2724:602:20;10404:1148:10;885:5467:20;10404:1148:10;2852:1:20;10404:1148:10;;1766:48;1762:126;;-1:-1:-1;;;3108:38:20;;2998:4;2966:38;3108;;885:5467;;3108:38;2966;3108;;;;;;;;2852:1;3108:38;;;2724:602;3108:54;;;;:::i;:::-;3176:13;;;3172:26;;885:5467;2852:1;885:5467;1809:4:10;885:5467:20;;;2852:1;885:5467;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;3207:44;885:5467;;;3207:44;:::i;:::-;885:5467;;;;;;;3266:53;885:5467;3045:10;3266:53;;2724:602::o;3172:26::-;3191:7;;;:::o;3108:38::-;;885:5467;3108:38;;885:5467;3108:38;;;;;;885:5467;3108:38;;;:::i;:::-;;;885:5467;;;;3108:54;885:5467;;3108:38;;;;;-1:-1:-1;3108:38:20;;;885:5467;;;2852:1;885:5467;;;;;1762:126:10;1837:40;;;;2852:1:20;1837:40:10;2966:38:20;885:5467;2966:38;2852:1;1837:40:10;10404:1148;1809:4;10404:1148;;;;;;;;;;;;;;;;;;2852:1:20;10404:1148:10;;;;;2966:38:20;;;885:5467;2966:38;;885:5467;2966:38;;;;;;885:5467;2966:38;;;:::i;:::-;;;885:5467;;;;;2966:38;;;;;;-1:-1:-1;2966:38:20;;2827:72;2886:13;;;2852:1;2886:13;;2852:1;2886:13;2831:46;-1:-1:-1;;;;;;885:5467:20;;2858:19;2831:46;;1910:254;-1:-1:-1;;;;;885:5467:20;1976:23;;1972:49;;2035:9;:14;2031:27;;885:5467;1997:1;885:5467;1997:1;885:5467;;;1997:1;885:5467;2067:33;2035:9;885:5467;;2067:33;:::i;:::-;885:5467;;;;2035:9;;885:5467;;2115:42;885:5467;2135:10;2115:42;;1910:254::o;2031:27::-;2051:7;:::o;3749:292:13:-;2407:1;-1:-1:-1;;;;;;;;;;;885:5467:20;4560:63:13;3644:93;;2407:1;-1:-1:-1;;;;;;;;;;;885:5467:20;3749:292:13:o;3644:93::-;3696:30;;;-1:-1:-1;3696:30:13;;-1:-1:-1;3696:30:13;5437:463:20;5529:11;;5525:35;;5603:10;5539:1;885:5467;5588:14;885:5467;;;5539:1;885:5467;;;;;;;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;;5635:16;;;5631:65;;5743:16;;;;:::i;:::-;5603:10;5539:1;885:5467;5588:14;885:5467;;;5539:1;885:5467;;;;;;;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;;;;;;;;;8544:1067:10;8509:24;;;5539:1:20;8544:1067:10;5603:10:20;8544:1067:10;;;;;885:5467:20;5539:1;8544:1067:10;;;;;;5588:14:20;5539:1;8544:1067:10;;;;;;;5437:463:20;8544:1067:10;885:5467:20;8544:1067:10;1305:38;1301:116;;885:5467:20;;;5831:39;885:5467;5603:10;5831:39;;5437:463;:::o;1301:116:10:-;1837:40;;;;5539:1:20;1366:40:10;8544:1067;885:5467:20;8544:1067:10;5539:1:20;1366:40:10;8544:1067;5588:14:20;8544:1067:10;;;;;;;;;;;;;;;;;;5539:1:20;8544:1067:10;;;;;5631:65:20;5660:36;;;;5539:1;5660:36;;885:5467;;;;5539:1;5660:36;5525:35;5549:11;;;5539:1;5549:11;;5539:1;5549:11;4886:463;4958:11;;4954:35;;5027:10;4968:1;885:5467;4968:1;885:5467;;;4968:1;885:5467;;5052:16;;;5048:65;;5148:16;;;;:::i;:::-;5027:10;4968:1;885:5467;4968:1;885:5467;;;4968:1;885:5467;;4968:1;5027:10;;;;;5189:43;;885:5467;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;:::i;:::-;;;4968:1;885:5467;;;;;;5246:5;5242:34;;885:5467;;;;;5292:27;885:5467;5027:10;5292:27;;4886:463;:::o;5242:34::-;5260:16;;;4968:1;5260:16;;4968:1;5260:16;885:5467;;;5048:65;5660:36;;;;4968:1;5077:36;;885:5467;;;;4968:1;5077:36","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220dbbc16195d46dd822a5bbc7c7a2c8ac6b3a2c13959882c7f071ff2c011021a2464736f6c63430008230033","offset":1879}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xad71e345cc366ea1bbea7106710ca19d22a909f3fe8918a2e3e056f43bf13ad5","blockNumber":"57816681","transactionIndex":"9","deployer":"0x42939046CeE36C4cADaA4fa8be999C2d5037FE4D"},"sources":{"src/BrishopFeeEscrow.sol":{"content":"// SPDX-License-Identifier: MIT\n// Derived from the MIT PONS v2 verified source. See ../NOTICE.md.\npragma solidity ^0.8.26;\n\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {IBrishopFeeEscrow} from \"./interfaces/IBrishop.sol\";\n\n/**\n * @title BrishopFeeEscrow\n * @notice Holds every v2 recipient's claimable balance in one place, so\n * protocol and creators claim revenue from across all of their pools in a\n * single transaction instead of collecting per position. Revenue arrives in\n * whichever asset the launch trades against: native ETH for a native launch,\n * and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves\n * and buyback vault credit this same ledger.\n */\ncontract BrishopFeeEscrow is ReentrancyGuard, IBrishopFeeEscrow {\n    using SafeERC20 for IERC20;\n\n    error ZeroAddress();\n    error NoBalance();\n    error TransferFailed();\n    error InsufficientBalance(uint256 requested, uint256 available);\n\n    event Credited(address indexed recipient, address indexed depositor, uint256 amount);\n    event CreditedToken(address indexed recipient, address indexed token, address indexed depositor, uint256 amount);\n    event Claimed(address indexed recipient, uint256 amount);\n    event ClaimedToken(address indexed recipient, address indexed token, uint256 amount);\n\n    mapping(address recipient => uint256 amount) private _balances;\n    mapping(address recipient => mapping(address token => uint256 amount)) private _tokenBalances;\n\n    /**\n     * @notice Credits `msg.value` to `recipient`'s claimable native ETH balance.\n     * @dev Permissionless by design: the caller can only ever add value they\n     * already attached to the call, so there is no privilege to gate.\n     */\n    function credit(address recipient) external payable {\n        if (recipient == address(0)) revert ZeroAddress();\n        if (msg.value == 0) return;\n        _balances[recipient] += msg.value;\n        emit Credited(recipient, msg.sender, msg.value);\n    }\n\n    /**\n     * @notice Pulls `amount` of `token` from the caller and credits it to `recipient`.\n     * @dev Permissionless by design: the caller can only credit tokens they\n     * already hold and approve, so there is no privilege to gate. Credits\n     * the actual balance delta rather than the nominal `amount`, so a\n     * fee-on-transfer or deflationary pairToken can never make this\n     * contract record more credited liability than it actually holds,\n     * which would otherwise starve whichever recipient claims that token\n     * last.\n     */\n    function creditToken(address recipient, address token, uint256 amount) external nonReentrant {\n        if (recipient == address(0) || token == address(0)) revert ZeroAddress();\n        if (amount == 0) return;\n        uint256 balanceBefore = IERC20(token).balanceOf(address(this));\n        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);\n        uint256 received = IERC20(token).balanceOf(address(this)) - balanceBefore;\n        if (received == 0) return;\n        _tokenBalances[recipient][token] += received;\n        emit CreditedToken(recipient, token, msg.sender, received);\n    }\n\n    /**\n     * @notice Pays out the caller's entire claimable native ETH balance.\n     */\n    function claim() external nonReentrant returns (uint256 amount) {\n        amount = _claim(_balances[msg.sender]);\n    }\n\n    /**\n     * @notice Pays out `amount` of the caller's claimable native ETH balance.\n     */\n    function claim(uint256 amount) external nonReentrant returns (uint256) {\n        return _claim(amount);\n    }\n\n    /**\n     * @notice Pays out the caller's entire claimable balance of `token`.\n     */\n    function claimToken(address token) external nonReentrant returns (uint256 amount) {\n        amount = _claimToken(token, _tokenBalances[msg.sender][token]);\n    }\n\n    /**\n     * @notice Pays out `amount` of the caller's claimable balance of `token`.\n     * @dev A recipient's balance aggregates credits from every launch, curve,\n     * curve and buyback release, and `creditToken` is permissionless, so a\n     * third party can enlarge that figure at will. Against a token with a\n     * fixed maximum per transfer, a single full-balance claim would then\n     * revert and leave the recipient unable to draw any of it. Choosing the\n     * amount keeps the aggregate from being a single point of failure, and\n     * lets a recipient work around any per-transfer limit its quote asset\n     * imposes.\n     */\n    function claimToken(address token, uint256 amount) external nonReentrant returns (uint256) {\n        return _claimToken(token, amount);\n    }\n\n    /**\n     * @dev Shared debit path for both native claim entry points.\n     */\n    function _claim(uint256 amount) private returns (uint256) {\n        if (amount == 0) revert NoBalance();\n        uint256 balance = _balances[msg.sender];\n        if (amount > balance) revert InsufficientBalance(amount, balance);\n\n        _balances[msg.sender] = balance - amount;\n        (bool sent,) = payable(msg.sender).call{value: amount}(\"\");\n        if (!sent) revert TransferFailed();\n\n        emit Claimed(msg.sender, amount);\n        return amount;\n    }\n\n    /**\n     * @dev Shared debit path for both ERC-20 claim entry points.\n     */\n    function _claimToken(address token, uint256 amount) private returns (uint256) {\n        if (amount == 0) revert NoBalance();\n        uint256 balance = _tokenBalances[msg.sender][token];\n        if (amount > balance) revert InsufficientBalance(amount, balance);\n\n        _tokenBalances[msg.sender][token] = balance - amount;\n        IERC20(token).safeTransfer(msg.sender, amount);\n\n        emit ClaimedToken(msg.sender, token, amount);\n        return amount;\n    }\n\n    /**\n     * @notice Returns the claimable native ETH balance for `recipient`.\n     */\n    function balanceOf(address recipient) external view returns (uint256) {\n        return _balances[recipient];\n    }\n\n    /**\n     * @notice Returns the claimable balance of `token` for `recipient`.\n     */\n    function balanceOfToken(address recipient, address token) external view returns (uint256) {\n        return _tokenBalances[recipient][token];\n    }\n}\n"},"src/interfaces/IBrishop.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\ninterface IBrishopFeeEscrow {\n    function credit(address recipient) external payable;\n    function creditToken(address recipient, address token, uint256 amount) external;\n    function claim() external returns (uint256);\n    function claim(uint256 amount) external returns (uint256);\n    function claimToken(address token) external returns (uint256);\n    function claimToken(address token, uint256 amount) external returns (uint256);\n    function balanceOf(address recipient) external view returns (uint256);\n    function balanceOfToken(address recipient, address token) external view returns (uint256);\n}\n\n// Names retained from PONS for fee-policy compatibility. buybackBurnBps funds\n// purchases locked in the five-year vault; it does not burn those tokens.\nstruct FeePolicySnapshot {\n    address protocolFeeRecipient;\n    uint16 protocolFeeShareBps;\n    uint16 buybackBurnBps;\n    uint16 hookFeeBps;\n    uint16 maxInternalPriceImpactBps;\n}\n\ninterface IBrishopFeePolicy {\n    function feeSweepOperator() external view returns (address);\n    function currentFeePolicy() external view returns (FeePolicySnapshot memory);\n}\n\ninterface IBrishopSnipeTax {\n    function snipeTaxStartBps() external view returns (uint256);\n    function snipeTaxSeconds() external view returns (uint256);\n}\n\ninterface IBrishopLaunchFactory {\n    struct LaunchedToken {\n        address token;\n        address curve;\n        address deployer;\n        address creatorFeeRecipient;\n        address pairToken;\n        uint16 creatorTaxBps;\n        bool buybackEnabled;\n        bool personality;\n        bool exists;\n    }\n    function getLaunchedToken(address token) external view returns (LaunchedToken memory);\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n *\n * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced\n * by the {ReentrancyGuardTransient} variant in v6.0.\n *\n * @custom:stateless\n */\nabstract contract ReentrancyGuard {\n    using StorageSlot for bytes32;\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.ReentrancyGuard\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\n\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    /**\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\n     * from being called, preventing reading from inconsistent contract state.\n     *\n     * CAUTION: This is a \"view\" modifier and does not change the reentrancy\n     * status. Use it only on view functions. For payable or non-payable functions,\n     * use the standard {nonReentrant} modifier instead.\n     */\n    modifier nonReentrantView() {\n        _nonReentrantBeforeView();\n        _;\n    }\n\n    function _nonReentrantBeforeView() private view {\n        if (_reentrancyGuardEntered()) {\n            revert ReentrancyGuardReentrantCall();\n        }\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        _nonReentrantBeforeView();\n\n        // Any calls to nonReentrant after this point will fail\n        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;\n    }\n\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\n        return REENTRANCY_GUARD_STORAGE;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"@openzeppelin/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.35+commit.47b9dedd","compilerSettings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"},"name":"BrishopFeeEscrow","fullyQualifiedName":"src/BrishopFeeEscrow.sol:BrishopFeeEscrow"},"abi":[{"name":"InsufficientBalance","type":"error","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"},{"name":"available","type":"uint256","internalType":"uint256"}]},{"name":"NoBalance","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"ZeroAddress","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ClaimedToken","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Credited","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"depositor","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CreditedToken","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"depositor","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"balanceOf","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"balanceOfToken","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claim","type":"function","inputs":[],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claimToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claimToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"credit","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"creditToken","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.35+commit.47b9dedd"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"},{"internalType":"uint256","name":"available","type":"uint256"}],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"NoBalance","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"TransferFailed","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Claimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ClaimedToken","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Credited","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"depositor","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"CreditedToken","type":"event"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"token","type":"address"}],"name":"balanceOfToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"claimToken","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"credit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"creditToken","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"kind":"dev","methods":{"claimToken(address,uint256)":{"details":"A recipient's balance aggregates credits from every launch, curve, curve and buyback release, and `creditToken` is permissionless, so a third party can enlarge that figure at will. Against a token with a fixed maximum per transfer, a single full-balance claim would then revert and leave the recipient unable to draw any of it. Choosing the amount keeps the aggregate from being a single point of failure, and lets a recipient work around any per-transfer limit its quote asset imposes."},"credit(address)":{"details":"Permissionless by design: the caller can only ever add value they already attached to the call, so there is no privilege to gate."},"creditToken(address,address,uint256)":{"details":"Permissionless by design: the caller can only credit tokens they already hold and approve, so there is no privilege to gate. Credits the actual balance delta rather than the nominal `amount`, so a fee-on-transfer or deflationary pairToken can never make this contract record more credited liability than it actually holds, which would otherwise starve whichever recipient claims that token last."}},"title":"BrishopFeeEscrow","version":1},"userdoc":{"kind":"user","methods":{"balanceOf(address)":{"notice":"Returns the claimable native ETH balance for `recipient`."},"balanceOfToken(address,address)":{"notice":"Returns the claimable balance of `token` for `recipient`."},"claim()":{"notice":"Pays out the caller's entire claimable native ETH balance."},"claim(uint256)":{"notice":"Pays out `amount` of the caller's claimable native ETH balance."},"claimToken(address)":{"notice":"Pays out the caller's entire claimable balance of `token`."},"claimToken(address,uint256)":{"notice":"Pays out `amount` of the caller's claimable balance of `token`."},"credit(address)":{"notice":"Credits `msg.value` to `recipient`'s claimable native ETH balance."},"creditToken(address,address,uint256)":{"notice":"Pulls `amount` of `token` from the caller and credits it to `recipient`."}},"notice":"Holds every v2 recipient's claimable balance in one place, so protocol and creators claim revenue from across all of their pools in a single transaction instead of collecting per position. Revenue arrives in whichever asset the launch trades against: native ETH for a native launch, and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves and buyback vault credit this same ledger.","version":1}},"settings":{"compilationTarget":{"src/BrishopFeeEscrow.sol":"BrishopFeeEscrow"},"evmVersion":"cancun","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts/interfaces/IERC1363.sol":{"keccak256":"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d","license":"MIT","urls":["bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100","dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d"]},"@openzeppelin/contracts/interfaces/IERC165.sol":{"keccak256":"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc","license":"MIT","urls":["bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037","dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ"]},"@openzeppelin/contracts/interfaces/IERC20.sol":{"keccak256":"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44","license":"MIT","urls":["bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d","dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2","license":"MIT","urls":["bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303","dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV"]},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0x304d732678032a9781ae85c8f204c8fba3d3a5e31c02616964e75cfdc5049098","license":"MIT","urls":["bzz-raw://299ced486011781dc98f638059678323c03079fefae1482abaa2135b22fa92d0","dweb:/ipfs/QmbZNbcPTBxNvwChavN2kkZZs7xHhYL7mv51KrxMhsMs3j"]},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0xa516cbf1c7d15d3517c2d668601ce016c54395bf5171918a14e2686977465f53","license":"MIT","urls":["bzz-raw://1e1d079e8edfb58efd23a311e315a4807b01b5d1cf153f8fa2d0608b9dec3e99","dweb:/ipfs/QmTBExeX2SDTkn5xbk5ssbYSx7VqRp9H4Ux1CY4uQM4b9N"]},"@openzeppelin/contracts/utils/StorageSlot.sol":{"keccak256":"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97","license":"MIT","urls":["bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b","dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c","license":"MIT","urls":["bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617","dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u"]},"src/BrishopFeeEscrow.sol":{"keccak256":"0x361a29a736f82d65989960e20cc37d80e5f0ec1ee909a4799df91bcef1141ca0","license":"MIT","urls":["bzz-raw://27624435e94dd282fc36e0d39ceceff413cbcf314b9c38350168b4accb739988","dweb:/ipfs/QmT73E2hkE4UKyy6ZqujJsNEjHLYvMnnQSyw2Xhcin4UU4"]},"src/interfaces/IBrishop.sol":{"keccak256":"0x329d57dfed260932f89ed7a9f0b91ed7236e12777f41ebf8599495ce294a8d2f","license":"MIT","urls":["bzz-raw://dd6053f039743beb42223b3228361129753dce8717c96291dba5820e52ef9892","dweb:/ipfs/QmeSF8Mo9XyXb3ZGp8ns6h2cLo1G8n4f8UyyUoHe8w4piF"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":8022,"label":"_balances","offset":0,"contract":"src/BrishopFeeEscrow.sol:BrishopFeeEscrow"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":8028,"label":"_tokenBalances","offset":0,"contract":"src/BrishopFeeEscrow.sol:BrishopFeeEscrow"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Holds every v2 recipient's claimable balance in one place, so protocol and creators claim revenue from across all of their pools in a single transaction instead of collecting per position. Revenue arrives in whichever asset the launch trades against: native ETH for a native launch, and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves and buyback vault credit this same ledger.","methods":{"claim()":{"notice":"Pays out the caller's entire claimable native ETH balance."},"claim(uint256)":{"notice":"Pays out `amount` of the caller's claimable native ETH balance."},"credit(address)":{"notice":"Credits `msg.value` to `recipient`'s claimable native ETH balance."},"balanceOf(address)":{"notice":"Returns the claimable native ETH balance for `recipient`."},"claimToken(address)":{"notice":"Pays out the caller's entire claimable balance of `token`."},"claimToken(address,uint256)":{"notice":"Pays out `amount` of the caller's claimable balance of `token`."},"balanceOfToken(address,address)":{"notice":"Returns the claimable balance of `token` for `recipient`."},"creditToken(address,address,uint256)":{"notice":"Pulls `amount` of `token` from the caller and credits it to `recipient`."}},"version":1},"devdoc":{"kind":"dev","title":"BrishopFeeEscrow","errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"methods":{"credit(address)":{"details":"Permissionless by design: the caller can only ever add value they already attached to the call, so there is no privilege to gate."},"claimToken(address,uint256)":{"details":"A recipient's balance aggregates credits from every launch, curve, curve and buyback release, and `creditToken` is permissionless, so a third party can enlarge that figure at will. Against a token with a fixed maximum per transfer, a single full-balance claim would then revert and leave the recipient unable to draw any of it. Choosing the amount keeps the aggregate from being a single point of failure, and lets a recipient work around any per-transfer limit its quote asset imposes."},"creditToken(address,address,uint256)":{"details":"Permissionless by design: the caller can only credit tokens they already hold and approve, so there is no privilege to gate. Credits the actual balance delta rather than the nominal `amount`, so a fee-on-transfer or deflationary pairToken can never make this contract record more credited liability than it actually holds, which would otherwise starve whichever recipient claims that token last."}},"version":1},"sourceIds":{"src/BrishopFeeEscrow.sol":{"id":20},"src/interfaces/IBrishop.sol":{"id":25},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":4},"@openzeppelin/contracts/utils/StorageSlot.sol":{"id":14},"@openzeppelin/contracts/interfaces/IERC165.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":7},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"id":2},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":13},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":10},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":15}},"additionalInput":null,"stdJsonInput":{"sources":{"src/BrishopFeeEscrow.sol":{"content":"// SPDX-License-Identifier: MIT\n// Derived from the MIT PONS v2 verified source. See ../NOTICE.md.\npragma solidity ^0.8.26;\n\nimport {ReentrancyGuard} from \"@openzeppelin/contracts/utils/ReentrancyGuard.sol\";\nimport {IERC20} from \"@openzeppelin/contracts/token/ERC20/IERC20.sol\";\nimport {SafeERC20} from \"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\";\nimport {IBrishopFeeEscrow} from \"./interfaces/IBrishop.sol\";\n\n/**\n * @title BrishopFeeEscrow\n * @notice Holds every v2 recipient's claimable balance in one place, so\n * protocol and creators claim revenue from across all of their pools in a\n * single transaction instead of collecting per position. Revenue arrives in\n * whichever asset the launch trades against: native ETH for a native launch,\n * and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves\n * and buyback vault credit this same ledger.\n */\ncontract BrishopFeeEscrow is ReentrancyGuard, IBrishopFeeEscrow {\n    using SafeERC20 for IERC20;\n\n    error ZeroAddress();\n    error NoBalance();\n    error TransferFailed();\n    error InsufficientBalance(uint256 requested, uint256 available);\n\n    event Credited(address indexed recipient, address indexed depositor, uint256 amount);\n    event CreditedToken(address indexed recipient, address indexed token, address indexed depositor, uint256 amount);\n    event Claimed(address indexed recipient, uint256 amount);\n    event ClaimedToken(address indexed recipient, address indexed token, uint256 amount);\n\n    mapping(address recipient => uint256 amount) private _balances;\n    mapping(address recipient => mapping(address token => uint256 amount)) private _tokenBalances;\n\n    /**\n     * @notice Credits `msg.value` to `recipient`'s claimable native ETH balance.\n     * @dev Permissionless by design: the caller can only ever add value they\n     * already attached to the call, so there is no privilege to gate.\n     */\n    function credit(address recipient) external payable {\n        if (recipient == address(0)) revert ZeroAddress();\n        if (msg.value == 0) return;\n        _balances[recipient] += msg.value;\n        emit Credited(recipient, msg.sender, msg.value);\n    }\n\n    /**\n     * @notice Pulls `amount` of `token` from the caller and credits it to `recipient`.\n     * @dev Permissionless by design: the caller can only credit tokens they\n     * already hold and approve, so there is no privilege to gate. Credits\n     * the actual balance delta rather than the nominal `amount`, so a\n     * fee-on-transfer or deflationary pairToken can never make this\n     * contract record more credited liability than it actually holds,\n     * which would otherwise starve whichever recipient claims that token\n     * last.\n     */\n    function creditToken(address recipient, address token, uint256 amount) external nonReentrant {\n        if (recipient == address(0) || token == address(0)) revert ZeroAddress();\n        if (amount == 0) return;\n        uint256 balanceBefore = IERC20(token).balanceOf(address(this));\n        IERC20(token).safeTransferFrom(msg.sender, address(this), amount);\n        uint256 received = IERC20(token).balanceOf(address(this)) - balanceBefore;\n        if (received == 0) return;\n        _tokenBalances[recipient][token] += received;\n        emit CreditedToken(recipient, token, msg.sender, received);\n    }\n\n    /**\n     * @notice Pays out the caller's entire claimable native ETH balance.\n     */\n    function claim() external nonReentrant returns (uint256 amount) {\n        amount = _claim(_balances[msg.sender]);\n    }\n\n    /**\n     * @notice Pays out `amount` of the caller's claimable native ETH balance.\n     */\n    function claim(uint256 amount) external nonReentrant returns (uint256) {\n        return _claim(amount);\n    }\n\n    /**\n     * @notice Pays out the caller's entire claimable balance of `token`.\n     */\n    function claimToken(address token) external nonReentrant returns (uint256 amount) {\n        amount = _claimToken(token, _tokenBalances[msg.sender][token]);\n    }\n\n    /**\n     * @notice Pays out `amount` of the caller's claimable balance of `token`.\n     * @dev A recipient's balance aggregates credits from every launch, curve,\n     * curve and buyback release, and `creditToken` is permissionless, so a\n     * third party can enlarge that figure at will. Against a token with a\n     * fixed maximum per transfer, a single full-balance claim would then\n     * revert and leave the recipient unable to draw any of it. Choosing the\n     * amount keeps the aggregate from being a single point of failure, and\n     * lets a recipient work around any per-transfer limit its quote asset\n     * imposes.\n     */\n    function claimToken(address token, uint256 amount) external nonReentrant returns (uint256) {\n        return _claimToken(token, amount);\n    }\n\n    /**\n     * @dev Shared debit path for both native claim entry points.\n     */\n    function _claim(uint256 amount) private returns (uint256) {\n        if (amount == 0) revert NoBalance();\n        uint256 balance = _balances[msg.sender];\n        if (amount > balance) revert InsufficientBalance(amount, balance);\n\n        _balances[msg.sender] = balance - amount;\n        (bool sent,) = payable(msg.sender).call{value: amount}(\"\");\n        if (!sent) revert TransferFailed();\n\n        emit Claimed(msg.sender, amount);\n        return amount;\n    }\n\n    /**\n     * @dev Shared debit path for both ERC-20 claim entry points.\n     */\n    function _claimToken(address token, uint256 amount) private returns (uint256) {\n        if (amount == 0) revert NoBalance();\n        uint256 balance = _tokenBalances[msg.sender][token];\n        if (amount > balance) revert InsufficientBalance(amount, balance);\n\n        _tokenBalances[msg.sender][token] = balance - amount;\n        IERC20(token).safeTransfer(msg.sender, amount);\n\n        emit ClaimedToken(msg.sender, token, amount);\n        return amount;\n    }\n\n    /**\n     * @notice Returns the claimable native ETH balance for `recipient`.\n     */\n    function balanceOf(address recipient) external view returns (uint256) {\n        return _balances[recipient];\n    }\n\n    /**\n     * @notice Returns the claimable balance of `token` for `recipient`.\n     */\n    function balanceOfToken(address recipient, address token) external view returns (uint256) {\n        return _tokenBalances[recipient][token];\n    }\n}\n"},"src/interfaces/IBrishop.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\ninterface IBrishopFeeEscrow {\n    function credit(address recipient) external payable;\n    function creditToken(address recipient, address token, uint256 amount) external;\n    function claim() external returns (uint256);\n    function claim(uint256 amount) external returns (uint256);\n    function claimToken(address token) external returns (uint256);\n    function claimToken(address token, uint256 amount) external returns (uint256);\n    function balanceOf(address recipient) external view returns (uint256);\n    function balanceOfToken(address recipient, address token) external view returns (uint256);\n}\n\n// Names retained from PONS for fee-policy compatibility. buybackBurnBps funds\n// purchases locked in the five-year vault; it does not burn those tokens.\nstruct FeePolicySnapshot {\n    address protocolFeeRecipient;\n    uint16 protocolFeeShareBps;\n    uint16 buybackBurnBps;\n    uint16 hookFeeBps;\n    uint16 maxInternalPriceImpactBps;\n}\n\ninterface IBrishopFeePolicy {\n    function feeSweepOperator() external view returns (address);\n    function currentFeePolicy() external view returns (FeePolicySnapshot memory);\n}\n\ninterface IBrishopSnipeTax {\n    function snipeTaxStartBps() external view returns (uint256);\n    function snipeTaxSeconds() external view returns (uint256);\n}\n\ninterface IBrishopLaunchFactory {\n    struct LaunchedToken {\n        address token;\n        address curve;\n        address deployer;\n        address creatorFeeRecipient;\n        address pairToken;\n        uint16 creatorTaxBps;\n        bool buybackEnabled;\n        bool personality;\n        bool exists;\n    }\n    function getLaunchedToken(address token) external view returns (LaunchedToken memory);\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"@openzeppelin/contracts/utils/StorageSlot.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC-1967 implementation slot:\n * ```solidity\n * contract ERC1967 {\n *     // Define the slot. Alternatively, use the SlotDerivation library to derive the slot.\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(newImplementation.code.length > 0);\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * TIP: Consider using this library along with {SlotDerivation}.\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    struct Int256Slot {\n        int256 value;\n    }\n\n    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `Int256Slot` with member `value` located at `slot`.\n     */\n    function getInt256Slot(bytes32 slot) internal pure returns (Int256Slot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns a `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns a `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        assembly (\"memory-safe\") {\n            r.slot := store.slot\n        }\n    }\n}\n"},"@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\n */\ninterface IERC20 {\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n\n    /**\n     * @dev Returns the value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(address from, address to, uint256 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\nimport {StorageSlot} from \"./StorageSlot.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n *\n * IMPORTANT: Deprecated. This storage-based reentrancy guard will be removed and replaced\n * by the {ReentrancyGuardTransient} variant in v6.0.\n *\n * @custom:stateless\n */\nabstract contract ReentrancyGuard {\n    using StorageSlot for bytes32;\n\n    // keccak256(abi.encode(uint256(keccak256(\"openzeppelin.storage.ReentrancyGuard\")) - 1)) & ~bytes32(uint256(0xff))\n    bytes32 private constant REENTRANCY_GUARD_STORAGE =\n        0x9b779b17422d0df92223018b32b4d1fa46e071723d6817e2486d003becc55f00;\n\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    /**\n     * @dev A `view` only version of {nonReentrant}. Use to block view functions\n     * from being called, preventing reading from inconsistent contract state.\n     *\n     * CAUTION: This is a \"view\" modifier and does not change the reentrancy\n     * status. Use it only on view functions. For payable or non-payable functions,\n     * use the standard {nonReentrant} modifier instead.\n     */\n    modifier nonReentrantView() {\n        _nonReentrantBeforeView();\n        _;\n    }\n\n    function _nonReentrantBeforeView() private view {\n        if (_reentrancyGuardEntered()) {\n            revert ReentrancyGuardReentrantCall();\n        }\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        _nonReentrantBeforeView();\n\n        // Any calls to nonReentrant after this point will fail\n        _reentrancyGuardStorageSlot().getUint256Slot().value = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _reentrancyGuardStorageSlot().getUint256Slot().value = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _reentrancyGuardStorageSlot().getUint256Slot().value == ENTERED;\n    }\n\n    function _reentrancyGuardStorageSlot() internal pure virtual returns (bytes32) {\n        return REENTRANCY_GUARD_STORAGE;\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that relies on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Oppositely, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0x00, 0x64, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0x00, 0x44, 0x00, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0x00, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.4.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun"}},"stdJsonOutput":{"sources":{"src/BrishopFeeEscrow.sol":{"id":20},"src/interfaces/IBrishop.sol":{"id":25},"@openzeppelin/contracts/interfaces/IERC20.sol":{"id":4},"@openzeppelin/contracts/utils/StorageSlot.sol":{"id":14},"@openzeppelin/contracts/interfaces/IERC165.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":7},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"id":2},"@openzeppelin/contracts/utils/ReentrancyGuard.sol":{"id":13},"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol":{"id":10},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":15}},"contracts":{"src/BrishopFeeEscrow.sol":{"BrishopFeeEscrow":{"abi":[{"name":"InsufficientBalance","type":"error","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"},{"name":"available","type":"uint256","internalType":"uint256"}]},{"name":"NoBalance","type":"error","inputs":[]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"TransferFailed","type":"error","inputs":[]},{"name":"ZeroAddress","type":"error","inputs":[]},{"name":"Claimed","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ClaimedToken","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Credited","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"depositor","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"CreditedToken","type":"event","inputs":[{"name":"recipient","type":"address","indexed":true,"internalType":"address"},{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"depositor","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"balanceOf","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"balanceOfToken","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"claim","type":"function","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claim","type":"function","inputs":[],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claimToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"claimToken","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"}],"outputs":[{"name":"amount","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"credit","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"creditToken","type":"function","inputs":[{"name":"recipient","type":"address","internalType":"address"},{"name":"token","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.35+commit.47b9dedd\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"available\",\"type\":\"uint256\"}],\"name\":\"InsufficientBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoBalance\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"TransferFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ZeroAddress\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Claimed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ClaimedToken\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Credited\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"CreditedToken\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"balanceOfToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"claim\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"claim\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"claimToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"claimToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"credit\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"creditToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"errors\":{\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"claimToken(address,uint256)\":{\"details\":\"A recipient's balance aggregates credits from every launch, curve, curve and buyback release, and `creditToken` is permissionless, so a third party can enlarge that figure at will. Against a token with a fixed maximum per transfer, a single full-balance claim would then revert and leave the recipient unable to draw any of it. Choosing the amount keeps the aggregate from being a single point of failure, and lets a recipient work around any per-transfer limit its quote asset imposes.\"},\"credit(address)\":{\"details\":\"Permissionless by design: the caller can only ever add value they already attached to the call, so there is no privilege to gate.\"},\"creditToken(address,address,uint256)\":{\"details\":\"Permissionless by design: the caller can only credit tokens they already hold and approve, so there is no privilege to gate. Credits the actual balance delta rather than the nominal `amount`, so a fee-on-transfer or deflationary pairToken can never make this contract record more credited liability than it actually holds, which would otherwise starve whichever recipient claims that token last.\"}},\"title\":\"BrishopFeeEscrow\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"balanceOf(address)\":{\"notice\":\"Returns the claimable native ETH balance for `recipient`.\"},\"balanceOfToken(address,address)\":{\"notice\":\"Returns the claimable balance of `token` for `recipient`.\"},\"claim()\":{\"notice\":\"Pays out the caller's entire claimable native ETH balance.\"},\"claim(uint256)\":{\"notice\":\"Pays out `amount` of the caller's claimable native ETH balance.\"},\"claimToken(address)\":{\"notice\":\"Pays out the caller's entire claimable balance of `token`.\"},\"claimToken(address,uint256)\":{\"notice\":\"Pays out `amount` of the caller's claimable balance of `token`.\"},\"credit(address)\":{\"notice\":\"Credits `msg.value` to `recipient`'s claimable native ETH balance.\"},\"creditToken(address,address,uint256)\":{\"notice\":\"Pulls `amount` of `token` from the caller and credits it to `recipient`.\"}},\"notice\":\"Holds every v2 recipient's claimable balance in one place, so protocol and creators claim revenue from across all of their pools in a single transaction instead of collecting per position. Revenue arrives in whichever asset the launch trades against: native ETH for a native launch, and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves and buyback vault credit this same ledger.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/BrishopFeeEscrow.sol\":\"BrishopFeeEscrow\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0xd5ea07362ab630a6a3dee4285a74cf2377044ca2e4be472755ad64d7c5d4b69d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://da5e832b40fc5c3145d3781e2e5fa60ac2052c9d08af7e300dc8ab80c4343100\",\"dweb:/ipfs/QmTzf7N5ZUdh5raqtzbM11yexiUoLC9z3Ws632MCuycq1d\"]},\"@openzeppelin/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0x0afcb7e740d1537b252cb2676f600465ce6938398569f09ba1b9ca240dde2dfc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1c299900ac4ec268d4570ecef0d697a3013cd11a6eb74e295ee3fbc945056037\",\"dweb:/ipfs/Qmab9owJoxcA7vJT5XNayCMaUR1qxqj1NDzzisduwaJMcZ\"]},\"@openzeppelin/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0x1a6221315ce0307746c2c4827c125d821ee796c74a676787762f4778671d4f44\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1bb2332a7ee26dd0b0de9b7fe266749f54820c99ab6a3bcb6f7e6b751d47ee2d\",\"dweb:/ipfs/QmcRWpaBeCYkhy68PR3B4AgD7asuQk7PwkWxrvJbZcikLF\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x74ed01eb66b923d0d0cfe3be84604ac04b76482a55f9dd655e1ef4d367f95bc2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5282825a626cfe924e504274b864a652b0023591fa66f06a067b25b51ba9b303\",\"dweb:/ipfs/QmeCfPykghhMc81VJTrHTC7sF6CRvaA1FXVq2pJhwYp1dV\"]},\"@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x304d732678032a9781ae85c8f204c8fba3d3a5e31c02616964e75cfdc5049098\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://299ced486011781dc98f638059678323c03079fefae1482abaa2135b22fa92d0\",\"dweb:/ipfs/QmbZNbcPTBxNvwChavN2kkZZs7xHhYL7mv51KrxMhsMs3j\"]},\"@openzeppelin/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0xa516cbf1c7d15d3517c2d668601ce016c54395bf5171918a14e2686977465f53\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1e1d079e8edfb58efd23a311e315a4807b01b5d1cf153f8fa2d0608b9dec3e99\",\"dweb:/ipfs/QmTBExeX2SDTkn5xbk5ssbYSx7VqRp9H4Ux1CY4uQM4b9N\"]},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"keccak256\":\"0xcf74f855663ce2ae00ed8352666b7935f6cddea2932fdf2c3ecd30a9b1cd0e97\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://9f660b1f351b757dfe01438e59888f31f33ded3afcf5cb5b0d9bf9aa6f320a8b\",\"dweb:/ipfs/QmarDJ5hZEgBtCmmrVzEZWjub9769eD686jmzb2XpSU1cM\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x8891738ffe910f0cf2da09566928589bf5d63f4524dd734fd9cedbac3274dd5c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://971f954442df5c2ef5b5ebf1eb245d7105d9fbacc7386ee5c796df1d45b21617\",\"dweb:/ipfs/QmadRjHbkicwqwwh61raUEapaVEtaLMcYbQZWs9gUkgj3u\"]},\"src/BrishopFeeEscrow.sol\":{\"keccak256\":\"0x361a29a736f82d65989960e20cc37d80e5f0ec1ee909a4799df91bcef1141ca0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://27624435e94dd282fc36e0d39ceceff413cbcf314b9c38350168b4accb739988\",\"dweb:/ipfs/QmT73E2hkE4UKyy6ZqujJsNEjHLYvMnnQSyw2Xhcin4UU4\"]},\"src/interfaces/IBrishop.sol\":{\"keccak256\":\"0x329d57dfed260932f89ed7a9f0b91ed7236e12777f41ebf8599495ce294a8d2f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dd6053f039743beb42223b3228361129753dce8717c96291dba5820e52ef9892\",\"dweb:/ipfs/QmeSF8Mo9XyXb3ZGp8ns6h2cLo1G8n4f8UyyUoHe8w4piF\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Holds every v2 recipient's claimable balance in one place, so protocol and creators claim revenue from across all of their pools in a single transaction instead of collecting per position. Revenue arrives in whichever asset the launch trades against: native ETH for a native launch, and the launch's ERC-20 quote asset otherwise. Brishop's permanent curves and buyback vault credit this same ledger.","methods":{"claim()":{"notice":"Pays out the caller's entire claimable native ETH balance."},"claim(uint256)":{"notice":"Pays out `amount` of the caller's claimable native ETH balance."},"credit(address)":{"notice":"Credits `msg.value` to `recipient`'s claimable native ETH balance."},"balanceOf(address)":{"notice":"Returns the claimable native ETH balance for `recipient`."},"claimToken(address)":{"notice":"Pays out the caller's entire claimable balance of `token`."},"claimToken(address,uint256)":{"notice":"Pays out `amount` of the caller's claimable balance of `token`."},"balanceOfToken(address,address)":{"notice":"Returns the claimable balance of `token` for `recipient`."},"creditToken(address,address,uint256)":{"notice":"Pulls `amount` of `token` from the caller and credits it to `recipient`."}},"version":1},"devdoc":{"kind":"dev","title":"BrishopFeeEscrow","errors":{"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"methods":{"credit(address)":{"details":"Permissionless by design: the caller can only ever add value they already attached to the call, so there is no privilege to gate."},"claimToken(address,uint256)":{"details":"A recipient's balance aggregates credits from every launch, curve, curve and buyback release, and `creditToken` is permissionless, so a third party can enlarge that figure at will. Against a token with a fixed maximum per transfer, a single full-balance claim would then revert and leave the recipient unable to draw any of it. Choosing the amount keeps the aggregate from being a single point of failure, and lets a recipient work around any per-transfer limit its quote asset imposes."},"creditToken(address,address,uint256)":{"details":"Permissionless by design: the caller can only credit tokens they already hold and approve, so there is no privilege to gate. Credits the actual balance delta rather than the nominal `amount`, so a fee-on-transfer or deflationary pairToken can never make this contract record more credited liability than it actually holds, which would otherwise starve whichever recipient claims that token last."}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_mapping(t_address,t_uint256)","astId":8022,"label":"_balances","offset":0,"contract":"src/BrishopFeeEscrow.sol:BrishopFeeEscrow"},{"slot":"1","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":8028,"label":"_tokenBalances","offset":0,"contract":"src/BrishopFeeEscrow.sol:BrishopFeeEscrow"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"885:5467:20:-:0;;;;;;;2365:1:13;1505:66;2365:1;885:5467:20;;;;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"885:5467:20:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;885:5467:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;-1:-1:-1;;885:5467:20;;;;-1:-1:-1;;;;;885:5467:20;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;2989:103:13;;:::i;:::-;3522:10:20;885:5467;;;;;;3505:29;885:5467;;;;3505:29;:::i;:::-;2365:1:13;-1:-1:-1;;;;;;;;;;;885:5467:20;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;2989:103:13;;:::i;:::-;885:5467:20;3730:14;885:5467;;3730:14;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;;3948:53;885:5467;;:::i;:::-;2989:103:13;;:::i;:::-;3982:10:20;885:5467;;;;3967:14;885:5467;;;;;;-1:-1:-1;;;;;885:5467:20;;;;;;;;;;3948:53;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;;4765:26;885:5467;;:::i;:::-;2989:103:13;;:::i;:::-;885:5467:20;;4765:26;;:::i;885:5467::-;;;;;;-1:-1:-1;;885:5467:20;;;;3054:1:13;885:5467:20;;:::i;:::-;;;:::i;:::-;2989:103:13;;:::i;:::-;885:5467:20;;3054:1:13;;:::i;:::-;885:5467:20;-1:-1:-1;;;;;;;;;;;885:5467:20;;;;;;-1:-1:-1;;;;;885:5467:20;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;885:5467:20;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;-1:-1:-1;885:5467:20;;;;;-1:-1:-1;885:5467:20;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;:::o;2724:602::-;-1:-1:-1;;;;;885:5467:20;;2724:602;2831:23;;:46;;;;2724:602;2827:72;;2913:11;;2909:24;;885:5467;;-1:-1:-1;;;2966:38:20;;2998:4;2966:38;;;885:5467;-1:-1:-1;;;;;885:5467:20;;;;;;;;2966:38;885:5467;;2966:38;;;;;;;2852:1;2966:38;;;2724:602;1767:47:10;885:5467:20;10404:1148:10;10365:28;;;;2852:1:20;10404:1148:10;3045:10:20;2966:38;10404:1148:10;2998:4:20;2966:38;10404:1148:10;;;885:5467:20;2852:1;10404:1148:10;;;;;;1809:4;2852:1:20;10404:1148:10;;;;;;;2724:602:20;10404:1148:10;885:5467:20;10404:1148:10;2852:1:20;10404:1148:10;;1766:48;1762:126;;-1:-1:-1;;;3108:38:20;;2998:4;2966:38;3108;;885:5467;;3108:38;2966;3108;;;;;;;;2852:1;3108:38;;;2724:602;3108:54;;;;:::i;:::-;3176:13;;;3172:26;;885:5467;2852:1;885:5467;1809:4:10;885:5467:20;;;2852:1;885:5467;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;3207:44;885:5467;;;3207:44;:::i;:::-;885:5467;;;;;;;3266:53;885:5467;3045:10;3266:53;;2724:602::o;3172:26::-;3191:7;;;:::o;3108:38::-;;885:5467;3108:38;;885:5467;3108:38;;;;;;885:5467;3108:38;;;:::i;:::-;;;885:5467;;;;3108:54;885:5467;;3108:38;;;;;-1:-1:-1;3108:38:20;;;885:5467;;;2852:1;885:5467;;;;;1762:126:10;1837:40;;;;2852:1:20;1837:40:10;2966:38:20;885:5467;2966:38;2852:1;1837:40:10;10404:1148;1809:4;10404:1148;;;;;;;;;;;;;;;;;;2852:1:20;10404:1148:10;;;;;2966:38:20;;;885:5467;2966:38;;885:5467;2966:38;;;;;;885:5467;2966:38;;;:::i;:::-;;;885:5467;;;;;2966:38;;;;;;-1:-1:-1;2966:38:20;;2827:72;2886:13;;;2852:1;2886:13;;2852:1;2886:13;2831:46;-1:-1:-1;;;;;;885:5467:20;;2858:19;2831:46;;1910:254;-1:-1:-1;;;;;885:5467:20;1976:23;;1972:49;;2035:9;:14;2031:27;;885:5467;1997:1;885:5467;1997:1;885:5467;;;1997:1;885:5467;2067:33;2035:9;885:5467;;2067:33;:::i;:::-;885:5467;;;;2035:9;;885:5467;;2115:42;885:5467;2135:10;2115:42;;1910:254::o;2031:27::-;2051:7;:::o;3749:292:13:-;2407:1;-1:-1:-1;;;;;;;;;;;885:5467:20;4560:63:13;3644:93;;2407:1;-1:-1:-1;;;;;;;;;;;885:5467:20;3749:292:13:o;3644:93::-;3696:30;;;-1:-1:-1;3696:30:13;;-1:-1:-1;3696:30:13;5437:463:20;5529:11;;5525:35;;5603:10;5539:1;885:5467;5588:14;885:5467;;;5539:1;885:5467;;;;;;;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;;5635:16;;;5631:65;;5743:16;;;;:::i;:::-;5603:10;5539:1;885:5467;5588:14;885:5467;;;5539:1;885:5467;;;;;;;;-1:-1:-1;885:5467:20;;;;-1:-1:-1;885:5467:20;;;;;;;;;8544:1067:10;8509:24;;;5539:1:20;8544:1067:10;5603:10:20;8544:1067:10;;;;;885:5467:20;5539:1;8544:1067:10;;;;;;5588:14:20;5539:1;8544:1067:10;;;;;;;5437:463:20;8544:1067:10;885:5467:20;8544:1067:10;1305:38;1301:116;;885:5467:20;;;5831:39;885:5467;5603:10;5831:39;;5437:463;:::o;1301:116:10:-;1837:40;;;;5539:1:20;1366:40:10;8544:1067;885:5467:20;8544:1067:10;5539:1:20;1366:40:10;8544:1067;5588:14:20;8544:1067:10;;;;;;;;;;;;;;;;;;5539:1:20;8544:1067:10;;;;;5631:65:20;5660:36;;;;5539:1;5660:36;;885:5467;;;;5539:1;5660:36;5525:35;5549:11;;;5539:1;5549:11;;5539:1;5549:11;4886:463;4958:11;;4954:35;;5027:10;4968:1;885:5467;4968:1;885:5467;;;4968:1;885:5467;;5052:16;;;5048:65;;5148:16;;;;:::i;:::-;5027:10;4968:1;885:5467;4968:1;885:5467;;;4968:1;885:5467;;4968:1;5027:10;;;;;5189:43;;885:5467;;;;;;;;;;;;;;;;;-1:-1:-1;;885:5467:20;;;;;:::i;:::-;;;4968:1;885:5467;;;;;;5246:5;5242:34;;885:5467;;;;;5292:27;885:5467;5027:10;5292:27;;4886:463;:::o;5242:34::-;5260:16;;;4968:1;5260:16;;4968:1;5260:16;885:5467;;;5048:65;5660:36;;;;4968:1;5077:36;;885:5467;;;;4968:1;5077:36","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"balanceOfToken(address,address)","signatureHash4":"0xf59e38b7","signatureHash32":"0xf59e38b758f11d1905b2106b49f5561f2a1e2b86f3c08a943480f69f7c15ea12"},{"signature":"claim()","signatureHash4":"0x4e71d92d","signatureHash32":"0x4e71d92d1cab44b435a6dcbe7dcfe75cf72953916cfa3842f5057ce194aa60e2"},{"signature":"claimToken(address)","signatureHash4":"0x32f289cf","signatureHash32":"0x32f289cf655e1f1d4ea6b2d42307f72b859ae2700cf3f50b716b8f2c3ecd5768"},{"signature":"claimToken(address,uint256)","signatureHash4":"0x1698755f","signatureHash32":"0x1698755f2f63264c31ca84d930df9dd8ca3ac92d33a0dd64d10154f95e4203ef"},{"signature":"claim(uint256)","signatureHash4":"0x379607f5","signatureHash32":"0x379607f58d976a91dd60b78d74592fb4bb001d7e08e70945c78343ec21864f46"},{"signature":"credit(address)","signatureHash4":"0xd5d44d80","signatureHash32":"0xd5d44d80ef4311ac82a2a6edbe04185d14b86ee4ed8df1488892229a73de3ec6"},{"signature":"creditToken(address,address,uint256)","signatureHash4":"0x09ad4dd9","signatureHash32":"0x09ad4dd9ff1d2d294f814095443899869aa5114143ed9dfb763c8d9dc37b6c3f"}],"event":[{"signature":"Claimed(address,uint256)","signatureHash4":"0xd8138f8a","signatureHash32":"0xd8138f8a3f377c5259ca548e70e4c2de94f129f5a11036a15b69513cba2b426a"},{"signature":"ClaimedToken(address,address,uint256)","signatureHash4":"0xdbc1ea3a","signatureHash32":"0xdbc1ea3a8459e4c7e11fb385b52bbb5cc8c8ab85eec5d883ac9aa78c171f5141"},{"signature":"Credited(address,address,uint256)","signatureHash4":"0x4e45da44","signatureHash32":"0x4e45da441832cf53bdaa69235704fc0575e68210f459ee1562911024b12967d5"},{"signature":"CreditedToken(address,address,address,uint256)","signatureHash4":"0x5d104c62","signatureHash32":"0x5d104c62f50449fadfe6f4013c8f36588d32737f94b5ac9b83ddad33b3e1ffdf"}],"error":[{"signature":"InsufficientBalance(uint256,uint256)","signatureHash4":"0xcf479181","signatureHash32":"0xcf4791818fba6e019216eb4864093b4947f674afada5d305e57d598b641dad1d"},{"signature":"NoBalance()","signatureHash4":"0xc2caa2a6","signatureHash32":"0xc2caa2a655620d9214a181153f7e526c8cc7951f07464b565624f7f2f2c8d093"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"},{"signature":"SafeERC20FailedOperation(address)","signatureHash4":"0x5274afe7","signatureHash32":"0x5274afe73c98b4749fc91ffae6b7b574e7842cb2144a159e9377a5f20b32edf9"},{"signature":"TransferFailed()","signatureHash4":"0x90b8ec18","signatureHash32":"0x90b8ec1877afffd816d05d9b13947f3ff18ec5851c38bad15ec2b710f92391b1"},{"signature":"ZeroAddress()","signatureHash4":"0xd92e233d","signatureHash32":"0xd92e233df2717d4a40030e20904abd27b68fcbeede117eaaccbbdac9618c8c73"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"4663","address":"0x899ECD0BB962D674Da4f4b1916200B70a7D37d1c"}