{"matchId":"58606590","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-11-06T08:24:12Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"411:125:4:-:0;;;;;;;;;;;;;-1:-1:-1;;411:125:4;;;;-1:-1:-1;;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;411:125:4;;;;;;;;5710:347:0;;;;-1:-1:-1;5710:347:0;;;;411:125:4;;;;;;;;;;-1:-1:-1;411:125:4;;;;;;-1:-1:-1;411:125:4;;;;;-1:-1:-1;411:125:4","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":9110,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000062fd9e98067b786e99a79f6ff4978a2e25df7124"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x6080604052600436101561001a575b3615610018575f80fd5b005b5f3560e01c8063068dcae71461064f57806325692962146105e857806354d1f13d14610586578063715018a6146104e95780638da5cb5b14610479578063bda3361c146103b6578063d73792a91461037b578063dbd3391914610283578063f04e283e14610218578063f2fde38b146101bf578063f940e385146100f65763fee81cf40361000e57346100f25760207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f2576100d961068f565b63389a75e1600c525f52602080600c2054604051908152f35b5f80fd5b346100f25760407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25761012d61068f565b6024359073ffffffffffffffffffffffffffffffffffffffff82168083036100f257610157610afb565b156101975773ffffffffffffffffffffffffffffffffffffffff811661018357506100189047906116c8565b610018916101913083610acd565b91611681565b7fd8707052000000000000000000000000000000000000000000000000000000005f5260045ffd5b60207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f2576101f161068f565b6101f9610afb565b8060601b1561020b5761001890610b32565b637448fbae5f526004601cfd5b60207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25761024a61068f565b610252610afb565b63389a75e1600c52805f526020600c209081544211610276575f6100189255610b32565b636f5e88185f526004601cfd5b6101207ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f2576102b661068f565b6102be6106b2565b906102c76106d5565b916102d06106f8565b60c43567ffffffffffffffff81116100f2576102f090369060040161071b565b909260e435919082151583036100f2576101043567ffffffffffffffff81116100f25761032190369060040161074c565b9590945f5c6103535760409861034498859460015f5d6064359160243590610c88565b5f805d82519182526020820152f35b7fab143c06000000000000000000000000000000000000000000000000000000005f5260045ffd5b346100f2575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f2576020604051620f42408152f35b6101407ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f2576103e961068f565b6103f16106b2565b906103fa6106d5565b916104036106f8565b60c43567ffffffffffffffff81116100f25761042390369060040161071b565b9092610104359182151583036100f2576101243567ffffffffffffffff81116100f25761045490369060040161074c565b9590945f5c610353576040986103449860015f5d60e435956064359160243590610c88565b346100f2575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25760207fffffffffffffffffffffffffffffffffffffffffffffffffffffffff748739275473ffffffffffffffffffffffffffffffffffffffff60405191168152f35b5f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25761051a610afb565b5f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927547f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a35f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff7487392755005b5f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25763389a75e1600c52335f525f6020600c2055337ffa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c925f80a2005b5f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25763389a75e1600c52335f526202a30042016020600c2055337fdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d5f80a2005b346100f2575f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc3601126100f25760206106876107b4565b604051908152f35b6004359073ffffffffffffffffffffffffffffffffffffffff821682036100f257565b6044359073ffffffffffffffffffffffffffffffffffffffff821682036100f257565b6084359073ffffffffffffffffffffffffffffffffffffffff821682036100f257565b60a4359073ffffffffffffffffffffffffffffffffffffffff821682036100f257565b9181601f840112156100f25782359167ffffffffffffffff83116100f2576020808501948460051b0101116100f257565b9181601f840112156100f25782359167ffffffffffffffff83116100f257602083818601950101116100f257565b9190820391821161078757565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601160045260245ffd5b3033036109ef5761010435906004359060243560a43560843573ffffffffffffffffffffffffffffffffffffffff80821615906044359060e4351660643589846109de575b50881590816109be575b816109b4575b81610923575b505f806040519b8c610144359182610164833760c43561012435f115610907576108509697989950806108f6575b6108e6575b5050156108d657504761077a565b9261088e5780831061085f5750565b827f5cebc26b000000000000000000000000000000000000000000000000000000005f5260045260245260445ffd5b80151590816108cb575b506108c957507f1fa0573e000000000000000000000000000000000000000000000000000000005f5260045260245ffd5b565b90508210155f610898565b6108e1903090610acd565b61077a565b6108ef91610a17565b5f80610842565b506109018183610a96565b1561083d565b3d8a6102008211610919575b815f823efd5b6102009150610913565b82601452806034526f095ea7b30000000000000000000000005f5260205f6044601082885af13d1560015f5114171615610963575b505f6034525f61080f565b5f6034526f095ea7b30000000000000000000000005f525f386044601083885af15060345260205f6044601082875af13d1560015f51141716156109a7575f610958565b633e3f8f735f526004601cfd5b8215159150610809565b73ffffffffffffffffffffffffffffffffffffffff841615159150610803565b6109e8919661077a565b94896107f9565b7f14d4a4e8000000000000000000000000000000000000000000000000000000005f5260045ffd5b906014525f6034526f095ea7b30000000000000000000000005f5260205f6044601082855af13d1560015f5114171615610a53575b505f603452565b5f6044601082602094816034526f095ea7b300000000000000000000000082528138858583855af150816034525af13d1560015f51141716156109a7575f610a4c565b604460105f92602094306014526034526fdd62ed3e0000000000000000000000008452617530fa5f5115601f3d111616905f603452565b602460106020939284936014526f70a082310000000000000000000000005f525afa601f3d11166020510290565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927543303610b2557565b6382b429005f526004601cfd5b73ffffffffffffffffffffffffffffffffffffffff16807fffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927547f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e05f80a37fffffffffffffffffffffffffffffffffffffffffffffffffffffffff7487392755565b90601f7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0910116810190811067ffffffffffffffff821117610bf457604052565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52604160045260245ffd5b67ffffffffffffffff8111610bf45760051b60200190565b90610c4382610c21565b610c506040519182610bb3565b8281527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0610c7e8294610c21565b0190602036910137565b99969b9894929a97959a9390938c156116595786158015611650575b6116205773ffffffffffffffffffffffffffffffffffffffff821615610197573073ffffffffffffffffffffffffffffffffffffffff8316146115f45773ffffffffffffffffffffffffffffffffffffffff8416156115cc5780156115a45773ffffffffffffffffffffffffffffffffffffffff831673ffffffffffffffffffffffffffffffffffffffff8c161461157c576040519a6102808c01938c851067ffffffffffffffff861117610bf45773ffffffffffffffffffffffffffffffffffffffff9660208e8980989581966040525f60c08401525f60e08401525f6101008401525f610120840152606061014084015260606101608401525f6101808401525f6101a08401525f6101c08401525f6101e08401525f6102008401525f61022084015216815201521660408c015260608b01521660808901521660a0870152151561026086015280610240860152610dfd87610c39565b610140860152610e0c87610c39565b6101608601527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6101e0860152610e43344761077a565b60c0860152845173ffffffffffffffffffffffffffffffffffffffff16806114eb5750602085015134106114c35784610eb29160208201516101208301525b604082015173ffffffffffffffffffffffffffffffffffffffff16806114b35750475b61010083015288886117c9565b6102008401511580156114a7575f90611464575b156113b057610edb6101e085015187876116e4565b610180850151905a915f9273ffffffffffffffffffffffffffffffffffffffff8851169160208901519273ffffffffffffffffffffffffffffffffffffffff60408b015116906101008b01519460a08701357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1883603018112156100f25787019182359267ffffffffffffffff84116100f2576020019083360382136100f2575f988998899686956080946040519a7f068dcae7000000000000000000000000000000000000000000000000000000008c528a60048d015260248c015260448b015260648a0152608489015260a488015260c48701378161014486015261016485013761016401923090f1806113a1575b61117457506102608401516110fa575b5f6110126101408601516101e0870151906117b5565b52610140840151610160850151908051915f6101808801525f6101a08801525f6101c08801527fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6101e08801525f5b8381106110715750505050610eb2565b8061107e600192856117b5565b51818c8c83611092575b5050505001611061565b6110aa926080926110a2926116e4565b013582612133565b906110c18b6110b985886117b5565b518484612155565b6110cf575b50818c8c611088565b6101808b01526101a08a01526110e581846117b5565b516101c08a0152806101e08a01525f806110c6565b6101e084015161111361110e8289896116e4565b611751565b907f5f2283a2b336dc5a06b5e101c3f9b1a23015ea989117f186b2612cdcb56c560e73ffffffffffffffffffffffffffffffffffffffff611152612208565b9361116c6040519283926020845216956020830190611772565b0390a3610ffc565b94849693956102008693949601525b604082015173ffffffffffffffffffffffffffffffffffffffff168061137157506111ce73ffffffffffffffffffffffffffffffffffffffff608084015116610200840151906116c8565b6102608201516112ae575b50505050506111ed4760c08401519061077a565b80611284575b5073ffffffffffffffffffffffffffffffffffffffff82511680611222575b506102006101e083015192015190565b61123061123b913090610acd565b60e08401519061077a565b80156112125761127e9073ffffffffffffffffffffffffffffffffffffffff84511673ffffffffffffffffffffffffffffffffffffffff60a08601511690611681565b5f611212565b6112a89073ffffffffffffffffffffffffffffffffffffffff60a0850151166116c8565b5f6111f3565b7f7ea83e2f986aa67ac44921ee3b35f1c36885cd0b3170986aaee1033a4f6ed6a5927fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f73ffffffffffffffffffffffffffffffffffffffff61131f61110e60a0966101e08901519a8b916116e4565b89610200880151956102406102208a0151990151604051998a9889526020890152604088015260806060880152816080880152878701375f868b87010152169701168101030190a35f808084816111d9565b61139c9073ffffffffffffffffffffffffffffffffffffffff60808501511661020085015191611681565b6111ce565b905060205f803e5f5190610fec565b61022084969594015185811061144f57867fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6101e082015114611427576060610180820151910151907f2c19b8b8000000000000000000000000000000000000000000000000000000005f5260045260245260445ffd5b7fb1895a8f000000000000000000000000000000000000000000000000000000005f5260045ffd5b868661145f928188999a98611b9c565b610eb2565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6101e085015114158015610ec6575061018084015160608501511115610ec6565b50909280959294611183565b6114be903090610acd565b610ea5565b7f1841b4e1000000000000000000000000000000000000000000000000000000005f5260045ffd5b6114f6903090610acd565b60e086015273ffffffffffffffffffffffffffffffffffffffff85511660205f6064601c82848b01519560405196606052306040523360601b602c526f23b872dd000000000000000000000000600c525af13d1560015f511417161561156f57610eb29186915f60605260405234610120830152610e82565b637939f4245f526004601cfd5b7f5c6d7b73000000000000000000000000000000000000000000000000000000005f5260045ffd5b7ffbabc0db000000000000000000000000000000000000000000000000000000005f5260045ffd5b7ffc62e08f000000000000000000000000000000000000000000000000000000005f5260045ffd5b7f17858bbe000000000000000000000000000000000000000000000000000000005f523060045260245ffd5b8c877fc679538f000000000000000000000000000000000000000000000000000000005f5260045260245260445ffd5b508c8711610ca4565b7fc7678ee6000000000000000000000000000000000000000000000000000000005f5260045ffd5b60105f60449260209582956014526034526fa9059cbb00000000000000000000000082525af13d1560015f51141716156116bb575f603452565b6390b8ec185f526004601cfd5b5f80809338935af1156116d757565b63b12d13eb5f526004601cfd5b91908110156117245760051b810135907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff41813603018212156100f2570190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52603260045260245ffd5b3573ffffffffffffffffffffffffffffffffffffffff811681036100f25790565b907fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0601f602080948051918291828752018686015e5f8582860101520116010190565b80518210156117245760209160051b010190565b9092919273ffffffffffffffffffffffffffffffffffffffff604084015116606084015190610120850151926102608601511515905f5b88811061181557505050505050506102200152565b6118208183896116e4565b606081013515611b74573073ffffffffffffffffffffffffffffffffffffffff61184983611751565b1614611b2a57608081013590620f4240821015611afa575f905f928b5f945f9360408101358d81115f14611a275750896040517fdade4665000000000000000000000000000000000000000000000000000000006020820152600481526118b1602482610bb3565b905b611963575b50506118cc575b5050505050600101611800565b90826118f18761016085896118e9846101406118f89a01516117b5565b5201516117b5565b5284612133565b828315611951575b611930575b5050611914578080808b6118bf565b6102008901526001016102209097019690965250505050505050565b836101808d01526101a08c01526101c08b0152826101e08b01525f80611905565b5061195e8c838387612155565b611900565b82156119c0575061198873ffffffffffffffffffffffffffffffffffffffff91611751565b167fb202ec83aa221eb19af3b64e325e0f5acfa21a8993dc9014656df95cedb8f3db604080518a8152896020820152a25b5f806118b8565b90611a1f73ffffffffffffffffffffffffffffffffffffffff611a037f94c0f5184378c50232ed4384249984a18c121cf41a9cb2d55b2c1c61375a401193611751565b16926040519182918c8352604060208401526040830190611772565b0390a26119b9565b8b159081611af0575b5015611a7557896040517ff247f39200000000000000000000000000000000000000000000000000000000602082015260048152611a6f602482610bb3565b906118b3565b955050509150505a905f90600185018086116107875787928e8e9214611ab1575b611aa1908287611ed7565b979197909792965a9003956118b3565b50611aa18a8b6101808401511015611acb575b9050611a96565b611ada846101a0850151611e2f565b8c8111611ae8575b50611ac4565b90505f611ae2565b905015155f611a30565b50907fe31b2b11000000000000000000000000000000000000000000000000000000005f5260045260245260445ffd5b611b4873ffffffffffffffffffffffffffffffffffffffff91611751565b7fc3e8aafc000000000000000000000000000000000000000000000000000000005f521660045260245ffd5b7ffc370e7d000000000000000000000000000000000000000000000000000000005f5260045ffd5b9193929373ffffffffffffffffffffffffffffffffffffffff6040850151166060850151610120860151936102608701511515935b888110611be657505050505050506102200152565b611bf18183896116e4565b606081013515611b74573073ffffffffffffffffffffffffffffffffffffffff611c1a83611751565b1614611b2a57608081013590620f4240821015611afa575f905f928b5f945f9360408101358d81115f14611db157508b6040517fdade466500000000000000000000000000000000000000000000000000000000602082015260048152611c82602482610bb3565b905b611d09575b5050611c9d575b5050505050600101611bd1565b90826118f18761016085896118e984610140611cba9a01516117b5565b828315611cf7575b611cd6575b5050611914578080808b611c90565b836101808d01526101a08c01526101c08b0152826101e08b01525f80611cc7565b50611d048c838387612155565b611cc2565b8215611d665750611d2e73ffffffffffffffffffffffffffffffffffffffff91611751565b167fb202ec83aa221eb19af3b64e325e0f5acfa21a8993dc9014656df95cedb8f3db604080518a8152896020820152a25b5f80611c89565b90611da973ffffffffffffffffffffffffffffffffffffffff611a037f94c0f5184378c50232ed4384249984a18c121cf41a9cb2d55b2c1c61375a401193611751565b0390a2611d5f565b8b159081611e25575b5015611dff578b6040517ff247f39200000000000000000000000000000000000000000000000000000000602082015260048152611df9602482610bb3565b90611c84565b95505050915050865a918b611e15888287611ed7565b979197909792965a900395611c84565b905015155f611dba565b8115611ed2577d10c6f7a0b5ed8d36b4c7f34938583621fafc8b0079a2834d26fa3fcc9ea98111611eac57620f4240828103910291620f424014611e7f578082049106611e795790565b60010190565b7f4e487b71000000000000000000000000000000000000000000000000000000005f52601260045260245ffd5b50507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff90565b905090565b91909260609073ffffffffffffffffffffffffffffffffffffffff855116611f0160208601611751565b93811561212b575b73ffffffffffffffffffffffffffffffffffffffff85161515968780612115575b6120c2575f9673ffffffffffffffffffffffffffffffffffffffff82511692602083015161010073ffffffffffffffffffffffffffffffffffffffff6040860151169401519460a08401357fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1853603018112156100f25784019081359167ffffffffffffffff83116100f25760200182360381136100f2575f97889788958594604051987f068dcae7000000000000000000000000000000000000000000000000000000008a52600160048b015260248a015260448901526064880152608487015260a486015260808660c4870137816101448601526101648501376101640192606030910135f194856120b5575b93859686159081612077575b61204e57505050565b8015612066575b61205d575050565b6108c991610a17565b506120718183610a96565b15612055565b60243d14612095575b8761204557945061208f612208565b94612045565b9550955060245f803e631fa0573e5f5160e01c1495600451870295612080565b5060205f803e5f51612039565b5050915093506120d29250612288565b50604051907fa7dedec10000000000000000000000000000000000000000000000000000000060208301526004825261210c602483610bb3565b5f915f915f9190565b5061212560208201518785612258565b15611f2a565b5f9450611f09565b90801561215157620f424003620f4240808281850602049204020190565b5090565b929190927fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff6101e0840151146121ff57606083015180821080156101808601519283101581036121f557506121e25750506101a08201518084119384156121be575b5050505090565b14925090826121d3575b50505f8080806121b7565b6101c001511190505f806121c8565b80821194509084156121be575050505090565b9550505050505090565b50505050600190565b3d90610200821161224e575b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0603f60405193808552805f602087013e84010116604052565b6102009150612214565b91906122658282856122be565b61228057826122778261227d95612288565b506122be565b90565b505050600190565b604460105f8093602095601452816034526f095ea7b300000000000000000000000082525af160015f51143d151716905f603452565b60105f60449260209582956014526034526f095ea7b300000000000000000000000082525af160015f51143d151716905f60345256","sourceMap":"411:125:4:-:0;;;;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11885:237:0;;;411:125:4;11885:237:0;411:125:4;11885:237:0;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;12478:70:0;;:::i;:::-;12548:16:5;12544:84;;411:125:4;;;;;12696:21:5;;;;;;:::i;12638:176::-;12772:30;12796:4;12772:30;12796:4;12772:30;;:::i;:::-;;;:::i;12544:84::-;12587:30;411:125:4;12587:30:5;411:125:4;;12587:30:5;411:125:4;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;8479:183::-;;411:125:4;8479:183:0;411:125:4;8479:183:0;;411:125:4;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;411:125:4;10506:526:0;411:125:4;10506:526:0;;;;;;;;;411:125:4;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;411:125:4;10506:526:0;411:125:4;10506:526:0;;411:125:4;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;1638:62:3;;411:125:4;;18941:136:5;411:125:4;;;;;;;;;;;18941:136:5;;:::i;:::-;411:125:4;;;;;;;;;;;;;1638:62:3;1677:12;411:125:4;1677:12:3;411:125:4;;1677:12:3;411:125:4;;;;;;;;;;;;;;11647:9:5;411:125:4;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;1638:62:3;;411:125:4;;22112:132:5;411:125:4;;;;;;;;;;;;22112:132:5;;:::i;411:125:4:-;;;;;;;;;;;;11523:61:0;;411:125:4;;;;;;;;;;;;;;;;12478:70:0;;:::i;:::-;411:125:4;6813:405:0;;;;;;411:125:4;6813:405:0;;411:125:4;;;;;;;;;9831:339:0;;;;411:125:4;9831:339:0;411:125:4;9831:339:0;;;;;;411:125:4;9831:339:0;;411:125:4;;;;;;;;;9239:383:0;;;;411:125:4;9239:383:0;7972:9;9132:15;411:125:4;9239:383:0;;;;;;411:125:4;9239:383:0;;411:125:4;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;44212:4044:5;44303:4;44281:10;:27;44277:75;;44620:920;;;;;;;;;;;;411:125:4;;;;45770:22:5;;44620:920;;;;;;;;;45770:22;45766:78;;44212:4044;46026:8;;;:33;;;;44212:4044;46026:58;;;44212:4044;46094:92;;;44212:4044;46413:716;-1:-1:-1;46413:716:5;;;;;;;;;;;;44620:920;;;;46413:716;;;;47474:31;47220:53;;;;;;;;44212:4044;47216:124;;44212:4044;-1:-1:-1;;47373:82:5;;;47398:21;;47474:31;:::i;:::-;47516:389;;;48159:18;;;48155:95;;44212:4044;:::o;48155:95::-;48200:39;;-1:-1:-1;48200:39:5;44620:920;411:125:4;44620:920:5;411:125:4;44620:920:5;-1:-1:-1;48200:39:5;47516:389;47770:14;;;:37;;;;47516:389;47766:89;;;47875:19;;-1:-1:-1;47875:19:5;44620:920;411:125:4;44620:920:5;-1:-1:-1;47875:19:5;47766:89;47827:13::o;47770:37::-;47788:19;;;;;47770:37;;;47373:82;47422:33;44303:4;;47422:33;;:::i;:::-;47474:31;:::i;47216:124::-;47289:40;;;:::i;:::-;47216:124;;;;47220:53;47239:34;;;;;:::i;:::-;47238:35;47220:53;;46413:716;;;;;;;;;;-1:-1:-1;46413:716:5;;;;;;-1:-1:-1;46413:716:5;;46094:92;17644:1483:1;;;;;;;-1:-1:-1;17644:1483:1;;-1:-1:-1;44620:920:5;17644:1483:1;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;46094:92:5;17644:1483:1;-1:-1:-1;17644:1483:1;;46094:92:5;;;17644:1483:1;-1:-1:-1;17644:1483:1;;;-1:-1:-1;17644:1483:1;-1:-1:-1;17644:1483:1;44620:920:5;17644:1483:1;;;;;;;;;-1:-1:-1;44620:920:5;17644:1483:1;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;;;;;;-1:-1:-1;17644:1483:1;44620:920:5;17644:1483:1;;46026:58:5;46063:21;;;;-1:-1:-1;46026:58:5;;:33;411:125:4;;;46038:21:5;;;-1:-1:-1;46026:33:5;;45766:78;45808:25;;;;:::i;:::-;45766:78;;;;44277:75;44331:10;;;;;;17509:1624:1;;17644:1483;;-1:-1:-1;17644:1483:1;;;-1:-1:-1;17644:1483:1;;-1:-1:-1;17644:1483:1;;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;17509:1624;17644:1483;-1:-1:-1;17644:1483:1;;17509:1624::o;17644:1483::-;-1:-1:-1;17644:1483:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;;;;55746:668:5;56047:361;;;55746:668;56047:361;55746:668;56047:361;;;;;;;;;;;;;;;;;;;;;;55746:668::o;19260:739:1:-;19403:590;;;19260:739;;;;19403:590;;;;;;;;;;;;;;19260:739;:::o;7292:355:0:-;7390:251;;;;;;7292:355::o;7390:251::-;;;;;;;6145:1089;6813:405;;;;;;-1:-1:-1;6813:405:0;;;;6145:1089::o;411:125:4:-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;411:125:4;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;:::o;22573:1135:5:-;;;;;;;;;;;;;;24345:15;;24341:63;;24593:14;;:40;;;;22573:1135;24589:117;;411:125:4;;;24720:23:5;24716:91;;24953:4;411:125:4;;;24932:26:5;24928:95;;411:125:4;;;25037:22:5;25033:89;;25136:17;;25132:77;;411:125:4;;;;;;25350:19:5;25346:74;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23392:28:5;;;:::i;:::-;411:125:4;;;23380:40:5;23443:28;;;:::i;:::-;411:125:4;;;23430:41:5;11357:17;411:125:4;;;;25769:33:5;25793:9;25769:21;:33;:::i;:::-;411:125:4;;;;;;;;26092:23:5;411:125:4;;;;;;11357:17:5;25793:9;26135:22;26131:85;;411:125:4;23540:44:5;411:125:4;;;;11357:17:5;411:125:4;;;;26088:387:5;411:125:4;;;;;;26661:24:5;;;26688:21;;26661:86;411:125:4;;;;23540:44:5;;;:::i;:::-;411:125:4;;;11357:17:5;34926:16;;;;;24359:1;23945:82;;;34919:1569;34962:13;34958:834;;36000:21;411:125:4;;;11357:17:5;36000:21;;;:::i;:::-;411:125:4;;;11357:17:5;36047:9;;35989:68;24359:1;411:125:4;;;;;;;;;11357:17:5;411:125:4;;;;;;;;;;;11357:17:5;49463:14;411:125:4;49463:14:5;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;49543:1164;;;;;;;411:125:4;49543:1164:5;411:125:4;49543:1164:5;;49500:33;49543:1164;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24953:4;;49543:1164;;;;;34919:1569;36071:102;;411:125:4;;;;;36187:143:5;;34919:1569;24359:1;36413:28;411:125:4;;;36413:9:5;411:125:4;;;11357:17:5;36413:28;;:::i;:::-;411:125:4;;;;37057:9:5;411:125:4;;;37104:10:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;11357:17:5;411:125:4;;;;24359:1:5;37291:9;;;;;;34919:1569;;;;;;37276:13;37337:10;;411:125:4;37337:10:5;;;:::i;:::-;11357:17;37365:14;;;;37361:349;;37276:13;411:125:4;;;;;37276:13:5;;37361:349;37413:35;37431:9;411:125:4;37431:9:5;;;;:::i;:::-;:16;411:125:4;37413:35:5;;:::i;:::-;37493:11;37470:38;37493:11;;;;;:::i;:::-;11357:17;37470:38;;;:::i;:::-;37466:230;;37361:349;;;;;;;37466:230;411:125:4;;;;;;;;37627:11:5;;;;:::i;:::-;11357:17;411:125:4;;;;;;;;;37466:230:5;;;;36187:143;411:125:4;;;11357:17:5;36264:28;:21;;;;;:::i;:::-;:28;:::i;:::-;36294:20;36228:87;411:125:4;36294:20:5;;:::i;:::-;411:125:4;;;;;;;;;;;;;;;;;:::i;:::-;36228:87:5;;;36187:143;;36071:102;411:125:4;;;;;;;;;;;;34919:1569:5;411:125:4;;;;;;41891:24:5;411:125:4;;;41959:11:5;411:125:4;;;;;;;;;11357:17:5;41959:11;;:::i;:::-;411:125:4;;;;42072:187:5;;41887:175;42288:21;;;;;:36;:21;411:125:4;;;11357:17:5;42288:36;;:::i;:::-;42338:12;42334:79;;41887:175;411:125:4;;;;;42427:23:5;42423:243;;41887:175;411:125:4;;;;;11357:17:5;411:125:4;;11357:17:5;22573:1135;:::o;42423:243::-;42487:34;:56;24953:4;;42487:34;;:::i;:::-;411:125:4;;;11357:17:5;42487:56;;:::i;:::-;42561:14;42557:99;42423:243;42557:99;42630:10;411:125:4;;;;;;;;;;;42630:10:5;;:::i;:::-;42557:99;42423:243;;42334:79;42393:8;411:125:4;;;;;;;42393:8:5;:::i;:::-;42334:79;;;42072:187;42109:139;411:125:4;;;;42154:28:5;:21;411:125:4;;;;;11357:17:5;42154:21;;;;:::i;:28::-;411:125:4;;;;11357:17:5;411:125:4;;;;;11357:17:5;411:125:4;;11357:17:5;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;;;;;;;;;42109:139:5;;;;42072:187;;;;;;;41887:175;42039:11;411:125:4;;;;;;;;;;11357:17:5;42039:11;;:::i;:::-;41887:175;;49543:1164;;;411:125:4;24359:1:5;49543:1164;;24359:1;49543:1164;;;;34958:834;411:125:4;;;;;;11357:17:5;35288:30;;;35284:167;;411:125:4;11357:17:5;411:125:4;;;11357:17:5;35612:26;35608:97;;411:125:4;;;;11357:17:5;411:125:4;;11357:17:5;35729:48;;24359:1;35729:48;49543:1164;411:125:4;49543:1164:5;411:125:4;49543:1164:5;24359:1;35729:48;35608:97;35669:17;24359:1;35669:17;49543:1164;24359:1;35669:17;35284:167;35400:1;;;;;;;;;;:::i;:::-;34919:1569;;23945:82;411:125:4;11357:17:5;411:125:4;;;11357:17:5;23966:26;;:60;;23945:82;23966:60;411:125:4;;;;11357:17:5;411:125:4;;;11357:17:5;-1:-1:-1;23996:30:5;23945:82;;34926:16;;;;;;;;;;26661:86;26712:35;24953:4;;26712:35;;:::i;:::-;26661:86;;26131:85;26184:17;24359:1;26184:17;;24359:1;26184:17;26088:387;26310:34;24953:4;;26310:34;;:::i;:::-;411:125:4;;;;;;;;;24359:1:5;9254:988:1;;411:125:4;;;;11357:17:5;9254:988:1;411:125:4;9254:988:1;;411:125:4;9254:988:1;24953:4:5;411:125:4;9254:988:1;26385:10:5;411:125:4;9254:988:1;;;;;;;;;;;24359:1:5;9254:988:1;;;;;;;23540:44:5;9254:988:1;;;24359:1:5;411:125:4;9254:988:1;411:125:4;9254:988:1;25793:9:5;411:125:4;;;;26088:387:5;;9254:988:1;;24359:1:5;9254:988:1;;;;25346:74:5;25392:17;24359:1;25392:17;;24359:1;25392:17;25132:77;25176:22;24359:1;25176:22;;24359:1;25176:22;25033:89;25082:29;24359:1;25082:29;;24359:1;25082:29;24928:95;24981:31;24359:1;24981:31;24953:4;24981:31;411:125:4;;24359:1:5;24981:31;24589:117;24656:39;;;24359:1;24656:39;;411:125:4;;;;24359:1:5;24656:39;24593:40;24611:22;;;;24593:40;;24341:63;24383:10;24359:1;24383:10;;24359:1;24383:10;13466:939:1;13593:806;;;13466:939;13593:806;13466:939;;;13593:806;;;;;;;;;;;;;;;;;;;;;;;13466:939::o;13593:806::-;;;;;;;4031:342;4146:221;4031:342;;;4146:221;;;;;;;4031:342::o;4146:221::-;;;;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;27929:5853:5:-;;;;;411:125:4;28141:10:5;;;411:125:4;;28184:14:5;;;11357:17;28232:15;;;;11357:17;28275:12;;;;411:125:4;;;28303:16:5;24359:1;28321:6;;;;;;33756:14;;;;;;;;;411:125:4;27929:5853:5:o;28303:16::-;28367:9;;;;;:::i;:::-;28184:14;28544;;411:125:4;28544:19:5;28540:88;;28967:4;411:125:4;28943:12:5;;;:::i;:::-;411:125:4;28943:29:5;28939:107;;29155:12;;;411:125:4;29185:25:5;11647:9;29185:25;;;29181:97;;24359:1;29320:12;24359:1;29346:14;;24359:1;29374:16;24359:1;29404:23;28141:10;29446:11;;411:125:4;29446:27:5;;;29442:2678;29446:27;;;411:125:4;;28141:10:5;411:125:4;29724:28:5;29701:52;;;;;;;;;;;:::i;:::-;29442:2678;;32134:248;;29442:2678;32396:1280;;;;29442:2678;411:125:4;;;;;;;28303:16:5;;32396:1280;32427:9;;32466:24;32427:9;32466:10;32427:9;;:21;:9;;32742:22;32427:9;;;:21;:::i;:::-;411:125:4;32466:10:5;;:24;:::i;:::-;411:125:4;32742:22:5;;:::i;:::-;32786:45;;;;;32396:1280;32782:231;;32396:1280;33456:206;;;;32396:1280;;;;;;33456:206;33493:11;;;411:125:4;;;33571:14:5;;;;411:125:4;;;;-1:-1:-1;;;;;;;33637:7:5:o;32782:231::-;32855:12;;;;411:125:4;32898:9:5;;;411:125:4;32935:9:5;;;411:125:4;32977:13:5;;;;411:125:4;32782:231:5;;;;32786:45;32799:32;;;;;;;:::i;:::-;32786:45;;32134:248;32168:200;;;;32231:12;;411:125:4;32231:12:5;;:::i;:::-;411:125:4;32208:44:5;28141:10;411:125:4;;;;;;;;;;32208:44:5;32168:200;32134:248;;;;32168:200;32324:12;411:125:4;;32324:12:5;32304:45;32324:12;;:::i;:::-;411:125:4;;28141:10:5;411:125:4;;;;;;;28141:10:5;411:125:4;;;;28141:10:5;411:125:4;;;;:::i;:::-;32304:45:5;;;32168:200;;29442:2678;29778:22;;:42;;;;29442:2678;-1:-1:-1;29774:2346:5;;;411:125:4;28141:10:5;411:125:4;30175:28:5;30152:52;;;;;;;;;;;:::i;:::-;29774:2346;29442:2678;;29774:2346;30477:9;;;;;;;;31319:23;24359:1;411:125:4;;;;;;;;;31453:11:5;;;;;;31449:383;;29774:2346;31893:43;;;;;:::i;:::-;31850:86;;;;;;32078:9;;411:125:4;;29774:2346:5;29442:2678;;31449:383;31488:30;31893:43;31488:30;31544:12;;;;11357:17;31544:28;;31540:274;;31449:383;;;;;31540:274;31621:26;31629:9;;;;11357:17;31621:26;:::i;:::-;31677:28;;;31673:119;;31540:274;;;;31673:119;31737:28;;31673:119;;;29778:42;29804:16;;;;29778:42;;;29181:97;29237:26;;;24359:1;29237:26;;411:125:4;;;;24359:1:5;29237:26;28939:107;29018:12;411:125:4;29018:12:5;;:::i;:::-;28999:32;24359:1;28999:32;411:125:4;28999:32:5;411:125:4;;24359:1:5;28999:32;28540:88;28590:23;24359:1;28590:23;;24359:1;28590:23;27929:5853;;;;;411:125:4;28141:10:5;;;411:125:4;;28184:14:5;;;11357:17;28232:15;;;11357:17;28275:12;;;;411:125:4;;;28303:16:5;28321:6;;;;;;33756:14;;;;;;;;;411:125:4;27929:5853:5:o;28303:16::-;28367:9;;;;;:::i;:::-;28184:14;28544;;411:125:4;28544:19:5;28540:88;;28967:4;411:125:4;28943:12:5;;;:::i;:::-;411:125:4;28943:29:5;28939:107;;29155:12;;;411:125:4;29185:25:5;11647:9;29185:25;;;29181:97;;-1:-1:-1;29320:12:5;-1:-1:-1;29346:14:5;;-1:-1:-1;29374:16:5;-1:-1:-1;29404:23:5;28141:10;29446:11;;411:125:4;29446:27:5;;;29442:2678;29446:27;;;411:125:4;;28141:10:5;411:125:4;29724:28:5;29701:52;;;;;;;;;;;:::i;:::-;29442:2678;;32134:248;;29442:2678;32396:1280;;;;29442:2678;411:125:4;;;;;;;28303:16:5;;32396:1280;32427:9;;32466:24;32427:9;32466:10;32427:9;;:21;:9;;32742:22;32427:9;;;:21;:::i;32742:22::-;32786:45;;;;;32396:1280;32782:231;;32396:1280;33456:206;;;;32396:1280;;;;;;32782:231;32855:12;;;;411:125:4;32898:9:5;;;411:125:4;32935:9:5;;;411:125:4;32977:13:5;;;;411:125:4;32782:231:5;;;;32786:45;32799:32;;;;;;;:::i;:::-;32786:45;;32134:248;32168:200;;;;32231:12;;411:125:4;32231:12:5;;:::i;:::-;411:125:4;32208:44:5;28141:10;411:125:4;;;;;;;;;;32208:44:5;32168:200;32134:248;;;;32168:200;32324:12;411:125:4;;32324:12:5;32304:45;32324:12;;:::i;411:125:4:-;32304:45:5;;;32168:200;;29442:2678;29778:22;;:42;;;;29442:2678;-1:-1:-1;29774:2346:5;;;411:125:4;28141:10:5;411:125:4;30175:28:5;30152:52;;;;;;;;;;;:::i;:::-;29774:2346;29442:2678;;29774:2346;30477:9;;;;;;;;;31319:23;31893:43;;;;;;:::i;:::-;31850:86;;;;;;32078:9;;411:125:4;;29774:2346:5;29442:2678;;29778:42;29804:16;;;;29778:42;;;41044:459;41135:11;;41131:52;;411:125:4;41196:41:5;;41192:96;;11647:9;411:125:4;;;;;41436:16:5;11647:9;411:125:4;;;;;;;;41456:21:5;;411:125:4;41044:459:5:o;41456:29::-;41484:1;411:125:4;;41044:459:5:o;411:125:4:-;;;;;;;;;;41192:96:5;41253:24;;41202:17;41253:24;:::o;41131:52::-;41162:10;;;:::o;51998:2928::-;;;;411:125:4;;;;;;52568:13:5;;;;;:::i;:::-;52595:21;;;52591:72;;51998:2928;411:125:4;;;52677:21:5;;;;;:67;;51998:2928;52673:708;;-1:-1:-1;411:125:4;;;;;49329:10:5;52568:13;49329:10;;11357:17;49415:18;411:125:4;49368:10:5;;;411:125:4;;49415:18:5;;11357:17;49463:14;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;52568:13:5;411:125:4;;;;;;;;-1:-1:-1;49543:1164:5;;;;;;;49368:10;49543:1164;;49500:33;49543:1164;;53715:4;49543:1164;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;411:125:4;49543:1164:5;53741:14;;411:125:4;49543:1164:5;;;;;51998:2928;53675:81;;53766:19;;53800:10;53796:676;;;;51998:2928;54482:438;;51998:2928;;;:::o;54482:438::-;54786:49;411:125:4;54786:49:5;;54482:438;54782:128;;51998:2928;;:::o;54782:128::-;54855:40;;;:::i;54786:49::-;54801:34;;;;;:::i;:::-;54800:35;54786:49;;53796:676;49543:1164;54081:288;;;;53796:676;54386:8;53796:676;54382:80;54427:20;;;;:::i;:::-;54382:80;53796:676;;54081:288;;;;;49543:1164;-1:-1:-1;54081:288:5;;;-1:-1:-1;54081:288:5;;;;;49543:1164;54081:288;;;;;;49543:1164;;52568:13;-1:-1:-1;49543:1164:5;;-1:-1:-1;49543:1164:5;;;52673:708;53122:29;;;;;;;;;;:::i;:::-;;411:125:4;;53317:52:5;53340:28;52568:13;53317:52;;;;;;;;;;:::i;:::-;-1:-1:-1;53292:78:5;-1:-1:-1;53292:78:5;-1:-1:-1;53292:78:5;;:::o;52677:67::-;52733:10;52703:41;52568:13;52733:10;;11357:17;52703:41;;;:::i;:::-;52702:42;52677:67;;52591:72;-1:-1:-1;;;52591:72:5;;39713:350;;39806:11;;39802:55;;11647:9;411:125:4;11647:9:5;411:125:4;;;;;;;;;;;39713:350:5;:::o;39802:55::-;39833:13;;:::o;38347:812::-;;;;;11357:17;38472:13;;;11357:17;38472:26;38468:68;;38571:14;;;11357:17;38561:24;;;;;38617:12;;;11357:17;38617:30;;;;38661:26;;38657:72;;38738:337;;;39097:9;;;;;11357:17;39091:15;;;:61;;;;;38347:812;39084:68;;;;38347:812;:::o;39091:61::-;39111:16;;-1:-1:-1;39111:16:5;;:40;;39091:61;;;;;;;;;39111:40;39142:9;;11357:17;-1:-1:-1;;;39111:40:5;;;;38738:337;38991:21;;;;-1:-1:-1;38991:21:5;:73;;;;38984:80;;;;;:::o;38657:72::-;38703:15;;;;;;;;:::o;38468:68::-;38514:11;;;;38521:4;38514:11;:::o;59070:488::-;59157:395;;;;;;;59070:488;59157:395;;;;;;;;;;;;;;;;;;;;59070:488::o;59157:395::-;;;-1:-1:-1;59157:395:5;;56883:270;;;56989:32;;;;;:::i;:::-;56985:74;;57069:27;;;57114:32;57069:27;;:::i;:::-;;57114:32;:::i;:::-;56883:270;:::o;56985:74::-;57037:11;;;57044:4;57037:11;:::o;57715:958::-;58335:332;;52228:9;57715:958;;58335:332;57715:958;58335:332;;;;;;;;;;;52228:9;58335:332;;;;;;;52228:9;58335:332;;57715:958::o;:::-;58335:332;;;57715:958;58335:332;57715:958;;;58335:332;;;;;;;;;;;;;;;;;;;;;57715:958::o","linkReferences":{},"cborAuxdata":{},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0xb436f2c1226162fe4b6067af32b57f5bf54d62b7056c1d618da220f6c9301f4d","blockNumber":"26354337","transactionIndex":"136","deployer":"0x62fd9e98067B786e99a79f6Ff4978a2E25dF7124"},"sources":{"src/route-racer/RouteRacer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\nimport {ReentrancyGuardTransient} from \"../common/ReentrancyGuardTransient.sol\";\n\nimport {RouteRacerBase} from \"./RouteRacerBase.sol\";\n\n/// @title  RouteRacer\n/// @notice `RouteRacerBase` with the reentrancy lock in transient storage.\n/// @dev    The default. Requires Cancun; use `RouteRacer_NonTstore` on chains\n///         without transient storage.\ncontract RouteRacer is RouteRacerBase, ReentrancyGuardTransient {\n    constructor(address _owner) RouteRacerBase(_owner) {}\n}\n"},"src/common/ReentrancyGuardTransient.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport {ReentrancyGuard} from \"./ReentrancyGuard.sol\";\n\n/// @title  ReentrancyGuardTransient\n/// @notice Reentrancy guard whose lock lives in EIP-1153 transient storage.\n/// @dev    Locking and unlocking costs about 300 gas, against roughly 2,300 for\n///         the storage backed guard on every call after the first (a cold SLOAD\n///         plus two dirty writes) and about 22,100 on the very first one. The\n///         lock clears itself at the end of the transaction, so the unlock only\n///         matters for a second guarded call in the same transaction.\n///\n///         Requires an EVM with `TSTORE` and `TLOAD` (Cancun). Chains without\n///         them get `ReentrancyGuardStorage` instead;\n///         `bash-utils/check-cancun-support.sh` reports which is which.\n///\n///         The lock is a `uint256` rather than a `bool` on purpose. Both compile\n///         to the same `TLOAD` and `TSTORE`, but a `bool` adds a normalization\n///         step on every read and write, measured at about 140 gas per guarded\n///         call and 48 bytes of extra code. Do not narrow the type.\n///\n///         Unlike `ReentrancyGuardStorage`, the slot here is assigned by the\n///         compiler rather than fixed at solady's slot. Transient storage is\n///         cleared at the end of the transaction, so there is nothing for\n///         offchain tooling to inspect afterwards and nothing that depends on\n///         the location.\nabstract contract ReentrancyGuardTransient is ReentrancyGuard {\n    uint256 private transient _locked;\n\n    modifier nonReentrant() override {\n        if (_locked != 0) {\n            revert Reentrancy();\n        }\n\n        _locked = 1;\n\n        _;\n\n        _locked = 0;\n    }\n}\n"},"src/route-racer/RouteRacerBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\nimport {Ownable} from \"solady/src/auth/Ownable.sol\";\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport {ReentrancyGuard} from \"../common/ReentrancyGuard.sol\";\n\n/// @notice A single candidate swap route to race\n/// @param target The swap provider router to call\n/// @param spender The address to approve for spending `tokenIn` (ignored when `tokenIn` is native)\n/// @param value The native value to forward with the call\n/// @param gasLimit The max gas made available to this route's trial and its\n///        real execution (must be nonzero so one route can never starve the\n///        other trials or the winner's execution; the EVM caps the forwarded\n///        amount at 63/64 of the remaining gas, so a deliberately high value\n///        effectively forwards all available gas)\n/// @param feePpm The fee the provider behind this route charges the caller\n///        on its output, in parts per million (100 is one basis point).\n///        Only steers the choice of winner: routes are ranked by output net\n///        of this fee, while the output delivered, the floor and the events\n///        stay raw. Zero means no fee; must be below `FEE_DENOMINATOR`\n/// @param callData The swap calldata to execute against `target`\nstruct Route {\n    address target;\n    address spender;\n    uint256 value;\n    uint256 gasLimit;\n    uint256 feePpm;\n    bytes callData;\n}\n\n/// @title  RouteRacerBase\n/// @notice Executes multiple candidate swap routes in isolated, state-reverting\n///         trial subcalls, records each outcome, then executes the route with\n///         the highest output net of its provider fee for real.\n/// @dev    Intended to be called by the RelayApprovalProxy in place of a single\n///         swap provider router. The caller approves this contract for `tokenIn`,\n///         this contract pulls the funds, races the routes, executes the winner\n///         and delivers the output to `recipient`.\n///\n///         Each trial runs in an external self call to `callRoute`. It\n///         reverts with `TrialResult(amountOut)` on swap success, or bubbles\n///         the provider's revert, so no trial leaves state behind. The one\n///         exception is a trial that clears its commit threshold (the last\n///         main when it beats every earlier trial and `minAmountOut`, or a\n///         backup at `minAmountOut`): that frame returns instead and keeps\n///         its execution, which fills the race without a second execution.\n///         Outcomes are recorded and emitted by the parent call, which is\n///         unaffected by the inner reverts.\n///\n///         A provider can charge the caller a fee on routed volume off\n///         chain, which a race on raw output cannot see: a route that\n///         delivers slightly more than a free one would win and cost the\n///         caller net. Each route therefore carries a `feePpm`, and the race\n///         ranks routes by output net of that fee. The fee only picks the\n///         winner: the output delivered to `recipient` is the raw output of\n///         the winner, `minAmountOut` is checked on that raw output, and the\n///         events report raw outputs. With every fee zero the race is a race\n///         on raw output.\n///\n///         Note: a malicious `target` could revert with spoofed `TrialResult`\n///         data to win the race, but a winner that did not keep its trial\n///         execution is re executed for real in a state reverting self call,\n///         its output is measured again and the attempt is rolled back\n///         unless the winner delivers at least its trial claimed output\n///         (which must itself be at least `minAmountOut`). On a rolled back\n///         attempt the race falls back to the next best route, so spoofing\n///         can neither steal funds nor block an otherwise fillable race.\n///\n///         Fee-on-transfer and rebasing tokens are unsupported: output is\n///         measured as this contract's balance delta and delivered via a\n///         plain transfer, so a transfer fee makes the recipient receive\n///         less than the checked minimum.\n///         All of the logic lives here and the reentrancy guard is left\n///         abstract, so `RouteRacer` (transient storage) and\n///         `RouteRacer_NonTstore` (regular storage) are one line each and\n///         cannot drift apart. Pick the one the target chain supports;\n///         `bash-utils/check-cancun-support.sh` reports which.\nabstract contract RouteRacerBase is Ownable, ReentrancyGuard {\n    using SafeTransferLib for address;\n\n    /// @notice Revert if no routes are provided\n    error NoRoutes();\n\n    /// @notice Revert if `mainCount` is zero, which would trial nothing, or\n    ///         exceeds the number of routes supplied\n    error InvalidMainCount(uint256 mainCount, uint256 routeCount);\n\n    /// @notice Revert if every route's trial failed\n    error AllRoutesFailed();\n\n    /// @notice Revert if the best trial output is below the minimum\n    error InsufficientOutput(uint256 amountOut, uint256 minAmountOut);\n\n    /// @notice Revert if the winner's executed output is below its trial-claimed output\n    error WinnerUnderperformed(uint256 amountOut, uint256 trialAmountOut);\n\n    /// @notice Revert if `minAmountOut` is zero, which would disable the theft guard\n    error MinAmountOutRequired();\n\n    /// @notice Revert if a route's `gasLimit` is zero, which would let it\n    ///         starve the other trials and the winner's execution\n    error RouteGasLimitRequired();\n\n    /// @notice Revert if a route targets this contract, which would make the\n    ///         contract its own caller and satisfy the `OnlySelf` gate on\n    ///         `callRoute`\n    error InvalidRouteTarget(address target);\n\n    /// @notice Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.\n    ///         A fee of the whole output leaves nothing to rank and would\n    ///         divide by zero in the commit threshold\n    error InvalidRouteFee(uint256 index, uint256 feePpm);\n\n    /// @notice Recorded as a route's trial failure reason when its `value`\n    ///         exceeds the native value provided by the caller for this fill\n    error ExcessiveRouteValue();\n\n    /// @notice Recorded as a route's trial failure reason when `tokenIn`\n    ///         cannot be approved for the route's spender\n    error RouteApprovalFailed();\n\n    /// @notice Recorded as a route's trial failure reason when the output is\n    ///         native and the route would forward native value. Output is\n    ///         measured as this contract's native balance delta, so any of\n    ///         that value the provider hands back would count as swap output:\n    ///         a refunded fee would go to the recipient instead of `refundTo`,\n    ///         `minAmountOut` would stop being a guarantee, and a route that\n    ///         simply returned what it was given could beat one that swaps\n    error ValueOnNativeOutput();\n\n    /// @notice Revert if msg.value does not cover a native `amountIn`\n    error InvalidMsgValue();\n\n    /// @notice Revert if `tokenIn` and `tokenOut` are the same token, which\n    ///         would break the balance-delta output measurement\n    error IdenticalTokens();\n\n    /// @notice Revert if a recipient is the zero address, either the race's\n    ///         `recipient` or a `withdraw` destination\n    error RecipientCannotBeZeroAddress();\n\n    /// @notice Revert if the recipient is this contract\n    error InvalidRecipient(address recipient);\n\n    /// @notice Revert if the refundTo address is the zero address\n    error RefundToCannotBeZeroAddress();\n\n    /// @notice Revert if `callRoute` is called by anyone other than this contract\n    error OnlySelf();\n\n    /// @notice Used as the success signal of a trial subcall, never a real failure\n    error TrialResult(uint256 amountOut);\n\n    /// @notice Emitted for each route trial that succeeded (when `emitEvents`\n    ///         is set)\n    /// @param index The index of the route in `routes`, where anything at or\n    ///        above the race's `mainCount` is a backup. A backup that the race\n    ///        never reached emits nothing, so use `trialedCount` on\n    ///        `RouteRaceWon` rather than counting these events to know how\n    ///        many candidates were tried. Not indexed: a consumer filters by\n    ///        race transaction, never by route index, and the topic cost more\n    ///        than the data word\n    /// @param target The swap provider router that was called\n    /// @param amountOut The measured output of the trial\n    event RouteTrialSucceeded(uint256 index, address indexed target, uint256 amountOut);\n\n    /// @notice Emitted for each route trial that failed (when `emitEvents` is\n    ///         set)\n    /// @param index The index of the route in `routes`, where anything at or\n    ///        above the race's `mainCount` is a backup\n    /// @param target The swap provider router that was called\n    /// @param revertData The (truncated) revert data of the failed trial\n    event RouteTrialFailed(uint256 index, address indexed target, bytes revertData);\n\n    /// @notice Emitted after the winning route is executed (when `emitEvents` is set)\n    /// @param index The index of the winning route in `routes`, where\n    ///        anything at or above the race's `mainCount` is a backup\n    /// @param target The swap provider router of the winning route\n    /// @param amountOut The actual executed output delivered to the recipient\n    /// @param trialedCount How many candidates were actually trialed, always a\n    ///        prefix of `routes`. Equals `mainCount` when the mains filled the\n    ///        race and the backups were never reached, so a consumer can tell\n    ///        a skipped candidate from a failed one instead of undercounting\n    ///        from the trial events\n    /// @param mainCount How many of `routes` were mains: `routes.length` on\n    ///        `race`, the caller's `mainCount` on `raceWithBackups`. With it\n    ///        the event alone tells a rescue (`index >= mainCount`) from a\n    ///        main's win and whether the backups ran at all (`trialedCount >\n    ///        mainCount`), without reading the race calldata\n    /// @param metadata Additional data to associate the race to\n    event RouteRaceWon(\n        uint256 indexed index,\n        address indexed target,\n        uint256 amountOut,\n        uint256 trialedCount,\n        uint256 mainCount,\n        bytes metadata\n    );\n\n    /// @notice Emitted when a selected route's real execution fails or\n    ///         under-delivers and is rolled back, before the race falls back\n    ///         to the next-best route (when `emitEvents` is set)\n    /// @param index The index of the failed route in `routes`, where anything\n    ///        at or above the race's `mainCount` is a backup\n    /// @param target The swap provider router that was called\n    /// @param revertData The (truncated) revert data of the failed execution\n    event RouteExecutionFailed(uint256 indexed index, address indexed target, bytes revertData);\n\n    /// @notice Max bytes of trial revert data copied back and emitted\n    uint256 private constant MAX_REVERT_DATA_BYTES = 512;\n\n    /// @notice Sentinel index meaning \"no successful route yet\"\n    uint256 private constant NO_WINNER = type(uint256).max;\n\n    /// @notice The unit of `Route.feePpm`: a fee of this many parts is the\n    ///         whole output. Parts per million, so a basis point is 100 and\n    ///         a deal quoted in fractions of a basis point still fits\n    uint256 public constant FEE_DENOMINATOR = 1_000_000;\n\n    /// @notice Gas given to the `allowance` read after a kept execution. A\n    ///         cold read through a proxy needs under 10,000; see\n    ///         `_allowanceIsZero` for why the frame's gas is not forwarded\n    uint256 private constant ALLOWANCE_READ_GAS = 30_000;\n\n    receive() external payable {}\n\n    constructor(address _owner) {\n        _initializeOwner(_owner);\n    }\n\n    /// @notice Withdraw funds that got stuck in the contract\n    /// @dev    Sweeps the whole balance. `onlyOwner`, so naming a recipient\n    ///         grants nothing the owner could not already do by withdrawing to\n    ///         themselves and transferring on; it only saves that second step\n    /// @param token The token to sweep, or address(0) for the native balance\n    /// @param to The address to send it to\n    function withdraw(address token, address to) external onlyOwner {\n        if (to == address(0)) {\n            revert RecipientCannotBeZeroAddress();\n        }\n\n        if (token == address(0)) {\n            to.safeTransferETH(address(this).balance);\n        } else {\n            token.safeTransfer(to, token.balanceOf(address(this)));\n        }\n    }\n\n    /// @notice Everything a race carries between its steps, in memory so the\n    ///         steps can be separate functions without a dozen stack values each\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native)\n    /// @param minAmountOut The caller's floor, and the backup trigger\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param preBalance The native balance this contract held before the\n    ///        call, which is never refunded or forwarded to a route\n    /// @param preTokenInBalance The `tokenIn` balance this contract held\n    ///        before the pull, which is never refunded either\n    /// @param outBalanceBefore This contract's `tokenOut` balance before any\n    ///        route ran, measured once because every frame that runs before\n    ///        the fill reverts\n    /// @param maxRouteValue The most native value any single route may forward\n    /// @param outputs Each trialed route's measured output, zero when it\n    ///        failed, was discarded, or was never reached\n    /// @param trialGas Gas each trialed route's trial consumed, measured in\n    ///        the parent frame around the trial call, zero when it failed or\n    ///        was never reached. Only read to break ties\n    /// @param bestOutput The raw trial output of the current leader, the\n    ///        route that would be executed if the trials stopped now. The\n    ///        leader is the eligible route (at or above `minAmountOut`) with\n    ///        the highest net output, or while none is eligible the route\n    ///        with the highest raw output, reported by `InsufficientOutput`\n    /// @param bestNet `bestOutput` net of the leader's fee, see `_netOf`\n    /// @param bestGas The trial gas of the leader\n    /// @param winnerIndex The leader, or `NO_WINNER`\n    /// @param amountOut Nonzero once a route has been executed for real: a\n    ///        trial that kept its execution, or a winner executed by\n    ///        `_executeBest`\n    /// @param trialedCount How many routes were trialed, always a prefix of\n    ///        the list\n    /// @param mainCount How many routes are mains, reported on the win event\n    /// @param emitEvents Whether to emit the per trial and winner events\n    struct RaceState {\n        // The race's arguments\n        address tokenIn;\n        uint256 amountIn;\n        address tokenOut;\n        uint256 minAmountOut;\n        address recipient;\n        address refundTo;\n        // Fixed before any route runs\n        uint256 preBalance;\n        uint256 preTokenInBalance;\n        uint256 outBalanceBefore;\n        uint256 maxRouteValue;\n        // What the trials found\n        uint256[] outputs;\n        uint256[] trialGas;\n        uint256 bestOutput;\n        uint256 bestNet;\n        uint256 bestGas;\n        uint256 winnerIndex;\n        uint256 amountOut;\n        uint256 trialedCount;\n        // Reporting\n        uint256 mainCount;\n        bool emitEvents;\n    }\n\n    /// @notice Pull `amountIn` of `tokenIn` from the caller, trial every route,\n    ///         execute the one with the highest output net of its fee and\n    ///         deliver its raw output of `tokenOut` to `recipient`\n    /// @dev    The caller must have approved this contract for `amountIn` of\n    ///         `tokenIn` (or send it as msg.value when `tokenIn` is native).\n    ///         Swap calldata must be built with this contract as taker/recipient\n    ///         so outputs land here and can be measured. Among the routes\n    ///         whose raw output clears `minAmountOut` the one with the\n    ///         highest output net of its `feePpm` wins; a route below the\n    ///         floor never wins over one that clears it, whatever its net.\n    ///         The last candidate keeps its own execution when its raw\n    ///         output already matches every earlier trial net of fees and\n    ///         clears the floor, which fills the race without a second\n    ///         execution, so order candidates worst to best by expected net\n    ///         output to hit that path. Among the other candidates an exact\n    ///         tie on net output goes to the route whose trial used less\n    ///         gas, not to the earlier one. Otherwise candidates are\n    ///         executed in descending net output order: an execution that\n    ///         fails or delivers less than its trial output is rolled back\n    ///         and the next-best route is tried instead. Reverts if every\n    ///         route fails, no trial output clears `minAmountOut`, or every\n    ///         candidate's execution fails. Leftover native and unspent\n    ///         input tokens are refunded to `refundTo`.\n    ///\n    ///         Every route here is a main: all of them are trialed. To hold\n    ///         some routes back as backups, call `raceWithBackups`.\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native, must differ from `tokenIn`)\n    /// @param minAmountOut The minimum acceptable executed output (must be > 0)\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param routes The candidate swap routes to race. Must not be empty\n    /// @param emitEvents Whether to emit per-trial and winner events\n    /// @param metadata Additional data to associate the race to\n    /// @return winnerIndex The index of the executed route\n    /// @return amountOut The actual output delivered to the recipient\n    function race(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        bool emitEvents,\n        bytes calldata metadata\n    ) external payable nonReentrant returns (uint256 winnerIndex, uint256 amountOut) {\n        return _race(\n            tokenIn, amountIn, tokenOut, minAmountOut, recipient, refundTo, routes, routes.length, emitEvents, metadata\n        );\n    }\n\n    /// @notice `race`, with the tail of `routes` held back as backups that are\n    ///         trialed only when the mains cannot fill the order\n    /// @dev    Identical to `race` except that only the first `mainCount`\n    ///         routes are trialed up front. The rest are reached only when\n    ///         the mains leave the race unfillable, meaning none of them\n    ///         succeeded, the best of them is below `minAmountOut`, or every\n    ///         main that cleared it failed its real execution, so a race\n    ///         whose mains fill never pays to trial a backup. A backup\n    ///         is a guard against a main failing, not against a main being\n    ///         mispriced: a main that clears the floor wins even where a\n    ///         backup would have paid more. Backups are not raced against\n    ///         each other either: they are trialed in order and the first\n    ///         that clears `minAmountOut` is executed, as its trial, so order\n    ///         them most reliable first. Both lists share one index space,\n    ///         mains first, so any index at or above `mainCount` is a backup.\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native, must differ from `tokenIn`)\n    /// @param minAmountOut The minimum acceptable executed output (must be > 0).\n    ///        This is doing double duty: it is both the caller's protection\n    ///        floor and the trigger for the backup routes, which are only\n    ///        trialed when the mains cannot clear it. Raising it therefore\n    ///        makes backups fire more often and also makes more fills revert,\n    ///        so choose it with both effects in mind\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param routes Every candidate, mains first then the backups. Must not\n    ///        be empty\n    /// @param mainCount How many of `routes` are mains. Must be nonzero and no\n    ///        greater than `routes.length`; equal to it means no backups,\n    ///        which is exactly `race`. The rest are tried in order until one\n    ///        clears the floor\n    /// @param emitEvents Whether to emit per-trial and winner events\n    /// @param metadata Additional data to associate the race to\n    /// @return winnerIndex The index of the executed route in `routes`, where\n    ///         anything at or above `mainCount` is a backup\n    /// @return amountOut The actual output delivered to the recipient\n    function raceWithBackups(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        uint256 mainCount,\n        bool emitEvents,\n        bytes calldata metadata\n    ) external payable nonReentrant returns (uint256 winnerIndex, uint256 amountOut) {\n        return _race(\n            tokenIn, amountIn, tokenOut, minAmountOut, recipient, refundTo, routes, mainCount, emitEvents, metadata\n        );\n    }\n\n    /// @notice The race itself, shared by both entrypoints: validate, pull the\n    ///         input, trial the mains, execute the best (trialing the backups\n    ///         if need be), deliver and refund\n    /// @dev    `race` passes `routes.length` as `mainCount`, so every route\n    ///         is a main there\n    function _race(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        uint256 mainCount,\n        bool emitEvents,\n        bytes calldata metadata\n    ) internal returns (uint256, uint256) {\n        _validate(tokenIn, tokenOut, minAmountOut, recipient, refundTo, routes.length, mainCount);\n\n        // The parameters are dead after this block; the steps read `s`\n        RaceState memory s;\n        s.tokenIn = tokenIn;\n        s.amountIn = amountIn;\n        s.tokenOut = tokenOut;\n        s.minAmountOut = minAmountOut;\n        s.recipient = recipient;\n        s.refundTo = refundTo;\n        s.emitEvents = emitEvents;\n        s.mainCount = mainCount;\n        s.outputs = new uint256[](routes.length);\n        s.trialGas = new uint256[](routes.length);\n        s.winnerIndex = NO_WINNER;\n\n        _pullInput(s);\n        _trialRoutes(routes, 0, mainCount, false, s);\n        _executeBest(routes, s);\n        _settle(routes, s, metadata);\n\n        return (s.winnerIndex, s.amountOut);\n    }\n\n    /// @notice Whether the trials so far can fill the race: a route kept its\n    ///         own execution, or the best trial clears the minimum\n    function _fillable(RaceState memory s) internal pure returns (bool) {\n        return s.amountOut != 0 || (s.winnerIndex != NO_WINNER && s.bestOutput >= s.minAmountOut);\n    }\n\n    /// @notice Reject the arguments a race can never run with\n    function _validate(\n        address tokenIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        uint256 routeCount,\n        uint256 mainCount\n    ) internal view {\n        if (routeCount == 0) {\n            revert NoRoutes();\n        }\n\n        // Zero would trial nothing, mains or backups; past the end would run\n        // off the array mid loop after earlier routes had already burned\n        // real trials\n        if (mainCount == 0 || mainCount > routeCount) {\n            revert InvalidMainCount(mainCount, routeCount);\n        }\n\n        if (recipient == address(0)) {\n            revert RecipientCannotBeZeroAddress();\n        }\n\n        // For safety, revert if the recipient is this contract, mirroring\n        // the RelayRouter behavior\n        if (recipient == address(this)) {\n            revert InvalidRecipient(address(this));\n        }\n\n        if (refundTo == address(0)) {\n            revert RefundToCannotBeZeroAddress();\n        }\n\n        if (minAmountOut == 0) {\n            revert MinAmountOutRequired();\n        }\n\n        // The output is measured as a balance delta, which is broken when\n        // the input and output tokens are the same\n        if (tokenIn == tokenOut) {\n            revert IdenticalTokens();\n        }\n    }\n\n    /// @notice Pull the input funds from the caller and take the balance\n    ///         snapshots the rest of the race measures against\n    function _pullInput(RaceState memory s) internal {\n        // Snapshot any pre-existing native balance so it is never refunded\n        // to the caller or forwarded to a route\n        s.preBalance = address(this).balance - msg.value;\n\n        // Pull the input funds from the caller, snapshotting any pre-existing\n        // input token balance so it is never refunded. A route can only\n        // forward native value provided by the caller for this fill, never\n        // the contract's own residual balance\n        if (s.tokenIn == address(0)) {\n            if (msg.value < s.amountIn) {\n                revert InvalidMsgValue();\n            }\n            s.maxRouteValue = s.amountIn;\n        } else {\n            s.preTokenInBalance = s.tokenIn.balanceOf(address(this));\n            s.tokenIn.safeTransferFrom(msg.sender, address(this), s.amountIn);\n            s.maxRouteValue = msg.value;\n        }\n\n        // Measured once: every trial and every failed execution reverts, so\n        // the output balance is the same before each of them (GAS.md step 7)\n        s.outBalanceBefore = s.tokenOut == address(0) ? address(this).balance : s.tokenOut.balanceOf(address(this));\n    }\n\n    /// @notice Trial `routes[from..to)` in isolated, state-reverting subcalls,\n    ///         recording each output and tracking the leader\n    /// @dev    A trial is run with a commit threshold when its result can end\n    ///         the race: if it measures at least `minAmountOut` and, net of\n    ///         its fee, at least as much as every earlier trial, it keeps\n    ///         its execution instead of rolling it back, which fills the\n    ///         race without a second execution.\n    ///\n    ///         Mains (`rescue` false) race: every one is trialed and\n    ///         only the last gets the threshold, so the best net output wins\n    ///         and the caller orders the likely winner last. Backups\n    ///         (`rescue` true) rescue: each is trialed with the\n    ///         threshold, the first that clears the floor keeps its execution\n    ///         and the rest are never trialed. Backups only run when the\n    ///         mains left the race unfillable, so competing them on price\n    ///         would spend a trial per backup for a fill that only needs one\n    ///         route that works; the caller orders the most reliable first\n    function _trialRoutes(Route[] calldata routes, uint256 from, uint256 to, bool rescue, RaceState memory s) internal {\n        // The loop invariants, read once instead of once per route\n        address tokenOut = s.tokenOut;\n        uint256 minAmountOut = s.minAmountOut;\n        uint256 maxRouteValue = s.maxRouteValue;\n        bool emitEvents = s.emitEvents;\n\n        for (uint256 i = from; i < to;) {\n            Route calldata route = routes[i];\n\n            // Every route must carry its own gas limit so a single route can\n            // never starve the other trials or the winner's execution\n            if (route.gasLimit == 0) {\n                revert RouteGasLimitRequired();\n            }\n\n            // A route that targets this contract would be its own caller, pass\n            // the `OnlySelf` gate on `callRoute` and re enter it with a forged\n            // payload, including a `tokenIn` this race never touched. Mirrors\n            // the `recipient == address(this)` rejection\n            if (route.target == address(this)) {\n                revert InvalidRouteTarget(route.target);\n            }\n\n            // Read once: the net output and the commit threshold both use it\n            uint256 feePpm = route.feePpm;\n            if (feePpm >= FEE_DENOMINATOR) {\n                revert InvalidRouteFee(i, feePpm);\n            }\n\n            bool committed;\n            bool success;\n            uint256 output;\n            uint256 trialGas;\n            bytes memory revertData;\n\n            if (route.value > maxRouteValue) {\n                // Record an over-value route as a failed trial without\n                // executing it, so it can neither win nor spend the\n                // contract's residual native balance\n                revertData = abi.encodeWithSelector(ExcessiveRouteValue.selector);\n            } else if (tokenOut == address(0) && route.value != 0) {\n                // A native output cannot be told apart from returned value,\n                // so a route that forwards value into a native output race\n                // fails its trial rather than being measured wrongly. This\n                // keeps `minAmountOut` a real floor on native output\n                revertData = abi.encodeWithSelector(ValueOnNativeOutput.selector);\n            } else {\n                // Measured around the whole trial, approval and clear\n                // included, since the winner's real execution repeats all of\n                // it. Only used to break an exact tie on output\n                uint256 gasBefore = gasleft();\n\n                // Zero always rolls back. The last main keeps its execution\n                // when it clears the floor and, net of its fee, matches the\n                // leader: the frame compares raw output against one word,\n                // so the leader's net is scaled back to the raw output this\n                // route needs for it. An ineligible leader sets no bar\n                // beyond the floor, since an eligible route beats it\n                // whatever its net. A backup commits at the floor and\n                // nothing higher: it only runs when no trialed route clears\n                // the floor, and a spoofed trial claiming more must not\n                // raise the bar for the honest backups after it, or the\n                // fill would go through the fallback and execute twice\n                uint256 commitThreshold;\n                if (rescue) {\n                    commitThreshold = minAmountOut;\n                } else if (i + 1 == to) {\n                    commitThreshold = minAmountOut;\n                    if (s.bestOutput >= minAmountOut) {\n                        uint256 rawToMatch = _rawFor(s.bestNet, feePpm);\n                        if (rawToMatch > commitThreshold) {\n                            commitThreshold = rawToMatch;\n                        }\n                    }\n                }\n\n                (committed, success, output, revertData) = _approveAndTrial(route, s, commitThreshold);\n\n                unchecked {\n                    // gas only goes down, so this cannot underflow\n                    trialGas = gasBefore - gasleft();\n                }\n            }\n\n            if (emitEvents) {\n                if (success) {\n                    emit RouteTrialSucceeded(i, route.target, output);\n                } else {\n                    emit RouteTrialFailed(i, route.target, revertData);\n                }\n            }\n\n            if (success) {\n                s.outputs[i] = output;\n                s.trialGas[i] = trialGas;\n\n                // A route that kept its execution wins outright even on an\n                // exact tie: keeping it costs nothing more, while any other\n                // winner would have to be executed a second time\n                uint256 net = _netOf(output, feePpm);\n                if (committed || _leads(output, net, trialGas, s)) {\n                    s.bestOutput = output;\n                    s.bestNet = net;\n                    s.bestGas = trialGas;\n                    s.winnerIndex = i;\n                }\n\n                // A kept execution fills the race and ends the search: a\n                // nonzero `amountOut` (always at least `minAmountOut`, which\n                // cannot be zero) is what tells the rest of the race so. A\n                // main only commits as the last of its range, a backup can\n                // commit anywhere in it, and `trialedCount` says where the\n                // search stopped either way\n                if (committed) {\n                    s.amountOut = output;\n                    unchecked {\n                        s.trialedCount = i + 1;\n                    }\n                    return;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n\n        s.trialedCount = to;\n    }\n\n    /// @notice Execute the trialed candidates in descending net output order\n    ///         until one delivers, trialing the backups whenever the trialed\n    ///         routes cannot fill the race\n    /// @dev    State did not change since the trials (they all reverted), but\n    ///         a route can still behave differently when re-executed (e.g. by\n    ///         observing the lower remaining gas or by having spoofed its\n    ///         trial), so each execution runs in its own state-reverting\n    ///         self-call: a failing or under-delivering attempt is rolled back\n    ///         and the next-best route is tried instead of losing the entire\n    ///         fill. Whenever nothing trialed is left that clears the floor,\n    ///         any backups not yet trialed are trialed and the search\n    ///         continues over them; when none are left the whole fill\n    ///         reverts. Only the re-measured output is ever delivered. Skipped\n    ///         entirely when the last trialed route already kept its execution\n    function _executeBest(Route[] calldata routes, RaceState memory s) internal {\n        while (s.amountOut == 0) {\n            if (!_fillable(s)) {\n                // Nothing trialed clears the floor: trial the backups now, on\n                // the same state the mains saw, since every failed execution\n                // rolled back. A backup that commits ends the loop; otherwise\n                // the best of them is executed next\n                if (s.trialedCount < routes.length) {\n                    _trialRoutes(routes, s.trialedCount, routes.length, true, s);\n                    continue;\n                }\n\n                // Revert the entire fill: no route succeeded, or even the\n                // best trial output cannot satisfy the minimum\n                if (s.winnerIndex == NO_WINNER) {\n                    revert AllRoutesFailed();\n                }\n                revert InsufficientOutput(s.bestOutput, s.minAmountOut);\n            }\n\n            // Forward all remaining gas; the route's own limit applies inside\n            // the frame, around the swap\n            (bool committed, uint256 executedAmountOut) =\n                _callRoute(routes[s.winnerIndex], false, s.bestOutput, s, gasleft());\n            if (committed) {\n                s.amountOut = executedAmountOut;\n                break;\n            }\n\n            if (s.emitEvents) {\n                emit RouteExecutionFailed(s.winnerIndex, routes[s.winnerIndex].target, _boundedRevertData());\n            }\n\n            // Discard the failed candidate and select the next best\n            s.outputs[s.winnerIndex] = 0;\n            _selectBest(routes, s);\n        }\n    }\n\n    /// @notice Point `winnerIndex`, `bestOutput` and `bestNet` at the best\n    ///         remaining trialed route, or at `NO_WINNER` and zero when none\n    ///         is left. Ranked by `_leads`, as the trial loop does. Net\n    ///         outputs are recomputed from the raw outputs and the routes'\n    ///         fees rather than kept per route: this only runs after a\n    ///         failed execution, so the hot path stores nothing\n    function _selectBest(Route[] calldata routes, RaceState memory s) internal pure {\n        uint256[] memory outputs = s.outputs;\n        uint256[] memory trialGas = s.trialGas;\n        uint256 count = outputs.length;\n        s.bestOutput = 0;\n        s.bestNet = 0;\n        s.bestGas = 0;\n        s.winnerIndex = NO_WINNER;\n        for (uint256 i = 0; i < count;) {\n            uint256 candidate = outputs[i];\n            if (candidate != 0) {\n                uint256 net = _netOf(candidate, routes[i].feePpm);\n                if (_leads(candidate, net, trialGas[i], s)) {\n                    s.bestOutput = candidate;\n                    s.bestNet = net;\n                    s.bestGas = trialGas[i];\n                    s.winnerIndex = i;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    /// @notice Whether a successful trial with raw `output`, `net` of its\n    ///         fee and costing `trialGas` takes the lead from the leader in\n    ///         `s`\n    /// @dev    Higher net output wins, among the routes that clear the floor\n    ///         first: a route below it can never be executed, so it must not\n    ///         hide one that can, however good its net. An exact tie goes to\n    ///         the route whose trial cost less gas, because the winner's\n    ///         real execution pays that gas again, not to the earlier one\n    function _leads(uint256 output, uint256 net, uint256 trialGas, RaceState memory s) private pure returns (bool) {\n        if (s.winnerIndex == NO_WINNER) {\n            return true;\n        }\n        bool eligible = output >= s.minAmountOut;\n        bool leaderEligible = s.bestOutput >= s.minAmountOut;\n        if (eligible != leaderEligible) {\n            return eligible;\n        }\n        if (!eligible) {\n            // Neither clears the floor, so neither can be executed and the\n            // net has no job: keep the highest raw output, which is what\n            // `InsufficientOutput` reports, as it did before fees\n            return output > s.bestOutput || (output == s.bestOutput && trialGas < s.bestGas);\n        }\n        return net > s.bestNet || (net == s.bestNet && trialGas < s.bestGas);\n    }\n\n    /// @notice `output` net of a `feePpm` fee, rounded down\n    /// @dev    Split at the denominator so the product never overflows: a\n    ///         trial output is whatever the route's frame reports, and a\n    ///         spoofed claim must cost that route the race, not the whole\n    ///         fill. The whole part times the kept share is at most the\n    ///         output and the remainder's share is below the denominator,\n    ///         so nothing here can overflow. Zero fee is the common case\n    ///         and skips the arithmetic\n    function _netOf(uint256 output, uint256 feePpm) private pure returns (uint256) {\n        if (feePpm == 0) {\n            return output;\n        }\n        unchecked {\n            uint256 keptPpm = FEE_DENOMINATOR - feePpm;\n            return (output / FEE_DENOMINATOR) * keptPpm + (output % FEE_DENOMINATOR) * keptPpm / FEE_DENOMINATOR;\n        }\n    }\n\n    /// @notice The smallest raw output whose net at `feePpm` is at least\n    ///         `net`: the inverse of `_netOf`, rounded up\n    /// @dev    `_netOf(raw, feePpm) >= net` holds exactly when `raw` is at\n    ///         least this, so the last main's commit threshold matches the\n    ///         comparison the trial loop would have made. A leader net above\n    ///         `max / FEE_DENOMINATOR` is a spoofed trial: no real token has\n    ///         an output that large, so the bar saturates to `max` instead\n    ///         of computing the exact inverse (which would still fit for\n    ///         some of those nets); such a last main rolls back and wins\n    ///         through the fallback instead, same amount delivered. `feePpm` is below\n    ///         `FEE_DENOMINATOR`, checked by the trial loop, so the divisor\n    ///         is nonzero, and the rounding step cannot overflow: a divisor\n    ///         of one leaves no remainder, a larger one leaves room\n    function _rawFor(uint256 net, uint256 feePpm) private pure returns (uint256) {\n        if (feePpm == 0) {\n            return net;\n        }\n        if (net > type(uint256).max / FEE_DENOMINATOR) {\n            return type(uint256).max;\n        }\n        unchecked {\n            uint256 keptPpm = FEE_DENOMINATOR - feePpm;\n            uint256 scaled = net * FEE_DENOMINATOR;\n            return scaled / keptPpm + (scaled % keptPpm == 0 ? 0 : 1);\n        }\n    }\n\n    /// @notice Deliver the output to the recipient, report the win with the\n    ///         race `metadata`, and refund any leftover native and unspent\n    ///         input tokens from this call to `refundTo`, excluding any\n    ///         pre-existing contract balance\n    function _settle(Route[] calldata routes, RaceState memory s, bytes calldata metadata) internal {\n        if (s.tokenOut == address(0)) {\n            s.recipient.safeTransferETH(s.amountOut);\n        } else {\n            s.tokenOut.safeTransfer(s.recipient, s.amountOut);\n        }\n\n        if (s.emitEvents) {\n            emit RouteRaceWon(\n                s.winnerIndex, routes[s.winnerIndex].target, s.amountOut, s.trialedCount, s.mainCount, metadata\n            );\n        }\n\n        uint256 leftover = address(this).balance - s.preBalance;\n        if (leftover > 0) {\n            s.refundTo.safeTransferETH(leftover);\n        }\n\n        if (s.tokenIn != address(0)) {\n            uint256 leftoverIn = s.tokenIn.balanceOf(address(this)) - s.preTokenInBalance;\n            if (leftoverIn > 0) {\n                s.tokenIn.safeTransfer(s.refundTo, leftoverIn);\n            }\n        }\n    }\n\n    /// @notice Run one route in its own call frame and measure its output.\n    ///         A trial reverts with `TrialResult(output)` so that everything\n    ///         the route did is discarded, unless the output clears the commit\n    ///         threshold, in which case the frame returns the output and keeps\n    ///         the execution. The winner's execution returns its output when\n    ///         that is at least the trial's claim and reverts with\n    ///         `WinnerUnderperformed` otherwise, so the race can roll it back\n    /// @dev    Only callable by this contract itself (via `_callRoute`), which\n    ///         is load bearing: the balance snapshot is an input, so a forged\n    ///         snapshot of zero would report the contract's whole `tokenOut`\n    ///         balance as one route's output. Takes no ABI arguments:\n    ///         `_callRoute` writes a fixed layout payload after the selector\n    ///         and this reads it back at the same offsets (GAS.md step 18).\n    ///         Layout, offsets from the start of calldata:\n    ///\n    ///           0x004  isTrial\n    ///           0x024  threshold (commit threshold for a trial, the trial\n    ///                  claimed output for the winner)\n    ///           0x044  tokenIn\n    ///           0x064  amountIn\n    ///           0x084  tokenOut\n    ///           0x0a4  outBalanceBefore\n    ///           0x0c4  target, spender, value, gasLimit (the route head)\n    ///           0x144  callData length\n    ///           0x164  callData bytes\n    function callRoute() external returns (uint256 output) {\n        if (msg.sender != address(this)) {\n            revert OnlySelf();\n        }\n\n        bool isTrial;\n        uint256 threshold;\n        address tokenIn;\n        uint256 amountIn;\n        address tokenOut;\n        uint256 outBalanceBefore;\n        address target;\n        address spender;\n        uint256 value;\n        uint256 gasLimit;\n        assembly (\"memory-safe\") {\n            isTrial := calldataload(0x04)\n            threshold := calldataload(0x24)\n            tokenIn := calldataload(0x44)\n            amountIn := calldataload(0x64)\n            tokenOut := calldataload(0x84)\n            outBalanceBefore := calldataload(0xa4)\n            // The route head was copied raw. `target` only ever feeds the\n            // `call` address operand, which the EVM truncates, but `spender`\n            // is compared with zero and handed to `approve` and `allowance`\n            // as a whole word, so it is masked here even though\n            // `_approveAndTrial` already rejected a dirty word before this\n            // frame could run\n            target := calldataload(0xc4)\n            spender := and(calldataload(0xe4), 0xffffffffffffffffffffffffffffffffffffffff)\n            value := calldataload(0x104)\n            gasLimit := calldataload(0x124)\n        }\n\n        // `race` measured this already and nothing changed since, because\n        // every trial and every failed execution reverts. Only the native\n        // value this call is about to spend has to be discounted\n        if (tokenOut == address(0)) {\n            outBalanceBefore -= value;\n        }\n\n        // Winner path only: a trial's approval is set and cleared by `race`\n        // in its own frame, where the write survives the trial's revert\n        bool approvalNeeded = !isTrial && tokenIn != address(0) && spender != address(0);\n        if (approvalNeeded) {\n            tokenIn.safeApproveWithRetry(spender, amountIn);\n        }\n\n        // Execute the swap, bounded by the route's gas limit, bubbling up\n        // the provider's revert (truncated to MAX_REVERT_DATA_BYTES, so a\n        // returndata bomb cannot eat the parent's gas) on failure\n        assembly (\"memory-safe\") {\n            // The swap calldata goes to the temporary region past the free\n            // memory pointer: nothing else needs it after the call, and the\n            // revert data below reuses the same region\n            let ptr := mload(0x40)\n            let cdLen := calldataload(0x144)\n            calldatacopy(ptr, 0x164, cdLen)\n            if iszero(call(gasLimit, target, value, ptr, cdLen, 0, 0)) {\n                let retSize := returndatasize()\n                if gt(retSize, MAX_REVERT_DATA_BYTES) {\n                    retSize := MAX_REVERT_DATA_BYTES\n                }\n                returndatacopy(ptr, 0, retSize)\n                revert(ptr, retSize)\n            }\n        }\n\n        // Clear any leftover approval, unless the swap already spent it all\n        if (approvalNeeded && !_allowanceIsZero(tokenIn, spender)) {\n            tokenIn.safeApproveWithRetry(spender, 0);\n        }\n\n        uint256 balanceAfter = tokenOut == address(0) ? address(this).balance : tokenOut.balanceOf(address(this));\n        output = balanceAfter - outBalanceBefore;\n\n        if (isTrial) {\n            // Keeping the execution is only ever an improvement on\n            // re-executing this same route: the output is measured here, in\n            // the frame that produced it, so there is nothing left to verify\n            if (threshold != 0 && output >= threshold) {\n                return output;\n            }\n            revert TrialResult(output);\n        }\n\n        // The route must deliver at least its trial-claimed output, so a\n        // route that spoofs or under-delivers is rolled back instead of\n        // extracting the surplus between its claim and the race's\n        // `minAmountOut`\n        if (output < threshold) {\n            revert WinnerUnderperformed(output, threshold);\n        }\n    }\n\n    /// @notice Build the fixed layout `callRoute` payload for `route` in the\n    ///         temporary region past the free memory pointer and self call\n    ///         with it. `route.callData` is bound through Solidity so the\n    ///         decoder's bounds checks still run\n    /// @return committed Whether the frame returned, meaning it kept its\n    ///         execution. The callee is this contract's `callRoute`, which\n    ///         returns exactly one word or reverts, so a returned frame always\n    ///         has 32 bytes of return data; the copy below relies on that and\n    ///         would halt the race if a future path returned nothing\n    /// @return output The returned output when `committed`, otherwise zero.\n    ///         The frame's return data is left in place for the caller to read\n    function _callRoute(Route calldata route, bool isTrial, uint256 threshold, RaceState memory s, uint256 gasToForward)\n        private\n        returns (bool committed, uint256 output)\n    {\n        address tokenIn = s.tokenIn;\n        uint256 amountIn = s.amountIn;\n        address tokenOut = s.tokenOut;\n        uint256 outBalanceBefore = s.outBalanceBefore;\n        bytes calldata cd = route.callData;\n        bytes4 sel = RouteRacerBase.callRoute.selector;\n        assembly (\"memory-safe\") {\n            let buf := mload(0x40)\n            // The selector first: the next word overwrites its low 28 bytes\n            mstore(buf, sel)\n            mstore(add(buf, 0x04), isTrial)\n            mstore(add(buf, 0x24), threshold)\n            mstore(add(buf, 0x44), tokenIn)\n            mstore(add(buf, 0x64), amountIn)\n            mstore(add(buf, 0x84), tokenOut)\n            mstore(add(buf, 0xa4), outBalanceBefore)\n            // The route head, raw: target, spender, value, gasLimit. The\n            // fee word that follows stays behind, the frame never reads it\n            calldatacopy(add(buf, 0xc4), route, 0x80)\n            mstore(add(buf, 0x144), cd.length)\n            calldatacopy(add(buf, 0x164), cd.offset, cd.length)\n            // `callRoute` returns its one output word when the frame kept\n            // its execution and reverts otherwise, so the call status alone\n            // says which\n            committed := call(gasToForward, address(), 0, buf, add(0x164, cd.length), 0, 0)\n            if committed {\n                returndatacopy(0x00, 0, 0x20)\n                output := mload(0x00)\n            }\n        }\n    }\n\n    /// @notice Approve the route's spender, trial the route, then clear the\n    ///         approval, keeping both allowance writes in this frame instead\n    ///         of the trial's\n    /// @dev    A rolled back trial reverts, so an approval written inside its\n    ///         frame would be discarded without a refund and its clear would\n    ///         never run. Writing the approve and the clear here, in the\n    ///         parent frame, makes the pair cheap (GAS.md step 3). Only one\n    ///         spender is approved at any moment, the same exposure as\n    ///         approving inside the trial.\n    /// @param route The route to trial\n    /// @param s The race, read for its input token and amount, its output\n    ///        token and its `tokenOut` balance snapshot\n    /// @param commitThreshold The output at or above which the trial keeps its\n    ///        execution instead of rolling it back; zero always rolls back\n    /// @return committed Whether the trial kept its execution, meaning the\n    ///         race is already filled by this route\n    /// @return success Whether the trial swap succeeded\n    /// @return output The measured output of the trial (0 on failure)\n    /// @return revertData The (truncated) revert data on failure, empty on success\n    function _approveAndTrial(Route calldata route, RaceState memory s, uint256 commitThreshold)\n        internal\n        returns (bool committed, bool success, uint256 output, bytes memory revertData)\n    {\n        address tokenIn = s.tokenIn;\n\n        // A zero spender means the route needs no approval, and a native\n        // input has no allowance to set. Read through Solidity even for a\n        // native input, so the calldata validator rejects dirty upper bits:\n        // `callRoute` copies the route head raw, so this is the only check\n        address spender = route.spender;\n        if (tokenIn == address(0)) {\n            spender = address(0);\n        }\n\n        if (spender != address(0) && !_tryApprove(tokenIn, spender, s.amountIn)) {\n            // A failed attempt can still have written an allowance while\n            // reporting failure, and unlike an approval made inside a trial\n            // frame there is no revert to undo it, so clear it before\n            // bailing out. Best effort by design: a token this broken must\n            // not be able to revert an otherwise fillable race\n            _approve(tokenIn, spender, 0);\n\n            // A route whose input cannot be approved fails its own trial\n            // rather than reverting the whole race\n            return (false, false, 0, abi.encodeWithSelector(RouteApprovalFailed.selector));\n        }\n\n        // Trial the route in a self call bounded by its gas limit so a bad\n        // route cannot eat the entire transaction's gas. The frame returns\n        // only when it kept its execution: the route is then the winner,\n        // already executed for real and already measured\n        (committed, output) = _callRoute(route, true, commitThreshold, s, route.gasLimit);\n        success = committed;\n\n        if (!committed) {\n            // A rolled back trial that succeeded reverts with exactly\n            // `TrialResult(uint256)`; anything else is the provider's own\n            // revert, copied (bounded) for reporting\n            bytes4 trialResult = TrialResult.selector;\n            assembly (\"memory-safe\") {\n                if eq(returndatasize(), 36) {\n                    returndatacopy(0x00, 0, 36)\n                    success := eq(shr(224, mload(0x00)), shr(224, trialResult))\n                    output := mul(success, mload(0x04))\n                }\n            }\n            if (!success) {\n                revertData = _boundedRevertData();\n            }\n        }\n\n        if (spender != address(0)) {\n            // Revoking is required to succeed: an allowance that cannot be\n            // cleared would outlive the race. A kept execution has usually\n            // spent the whole allowance already, and a slot that reads zero\n            // needs no write\n            if (!committed || !_allowanceIsZero(tokenIn, spender)) {\n                tokenIn.safeApproveWithRetry(spender, 0);\n            }\n        }\n    }\n\n    /// @notice Whether `spender`'s allowance on `token` for this contract\n    ///         reads as zero. A failed or short read counts as nonzero, so\n    ///         the caller falls back to clearing it\n    /// @dev    The read gets a fixed gas stipend, not the frame's gas: a token\n    ///         whose `allowance` writes state halts the static frame, and\n    ///         with `gas()` forwarded that halt would burn 63/64 of the race.\n    ///         Within the stipend the read either answers or fails, and a\n    ///         failure means the clear runs as it always did. A token whose\n    ///         `allowance` lies (zero while a real allowance stands) keeps\n    ///         that allowance after a kept execution; only this contract's\n    ///         future balance of that token is exposed, never a user's\n    function _allowanceIsZero(address token, address spender) private view returns (bool zero) {\n        // Same scratch layout as `_approve`: `allowance(address,address)`\n        // from 0x10, `spender` runs into the zero high bytes of the free\n        // memory pointer and is zeroed afterwards\n        assembly (\"memory-safe\") {\n            mstore(0x14, address())\n            mstore(0x34, spender)\n            mstore(0x00, 0xdd62ed3e000000000000000000000000)\n            zero := staticcall(ALLOWANCE_READ_GAS, token, 0x10, 0x44, 0x00, 0x20)\n            zero := and(zero, and(gt(returndatasize(), 0x1f), iszero(mload(0x00))))\n            mstore(0x34, 0)\n        }\n    }\n\n    /// @notice Approve `spender` for `amount` of `token`, reporting failure\n    ///         instead of reverting\n    /// @dev    Mirrors solady's `safeApproveWithRetry`, including the retry\n    ///         after resetting the allowance to zero that tokens like USDT\n    ///         require, but returns false instead of reverting so a single\n    ///         unapprovable route cannot kill an otherwise fillable race\n    /// @return Whether the allowance was set\n    function _tryApprove(address token, address spender, uint256 amount) private returns (bool) {\n        if (_approve(token, spender, amount)) {\n            return true;\n        }\n\n        _approve(token, spender, 0);\n\n        return _approve(token, spender, amount);\n    }\n\n    /// @notice Single `approve` attempt that never reverts\n    /// @dev    Succeeds when the call did and returned nothing (nonstandard\n    ///         tokens) or a first word equal to one, as solady does. Any\n    ///         other return reports failure instead of reverting, so one odd\n    ///         token cannot kill the race. Only the first word is ever read,\n    ///         so a token that returns a lot of data cannot make the race run\n    ///         out of gas on a copy\n    /// @return ok Whether the call succeeded and did not report failure\n    function _approve(address token, address spender, uint256 amount) private returns (bool ok) {\n        // solady's `approve` layout: the payload is the 0x44 bytes from\n        // 0x10, with the selector at 0x10, the `spender` word at 0x14 (its\n        // address bytes at 0x20) and the `amount` word at 0x34. That last\n        // word runs into the free memory pointer's high bytes, which are\n        // always zero, so zeroing it afterwards restores the pointer. The\n        // selector is written last so its zero tail cleans the high bytes\n        // of `spender`. The return word lands at 0x00, read in place\n        assembly (\"memory-safe\") {\n            mstore(0x14, spender)\n            mstore(0x34, amount)\n            mstore(0x00, 0x095ea7b3000000000000000000000000)\n            ok := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            ok := and(ok, or(iszero(returndatasize()), eq(mload(0x00), 1)))\n            mstore(0x34, 0)\n        }\n    }\n\n    /// @notice Copy at most `MAX_REVERT_DATA_BYTES` of the last call's\n    ///         revert data for reporting\n    /// @dev    Same bound as the inline one in `callRoute`. The bytes are\n    ///         allocated here without zero filling: only `size` bytes are\n    ///         ever read, and the event encoder writes its own padding\n    /// @return revertData The (truncated) revert data\n    function _boundedRevertData() private pure returns (bytes memory revertData) {\n        assembly (\"memory-safe\") {\n            let size := returndatasize()\n            if gt(size, MAX_REVERT_DATA_BYTES) {\n                size := MAX_REVERT_DATA_BYTES\n            }\n            revertData := mload(0x40)\n            mstore(revertData, size)\n            returndatacopy(add(revertData, 0x20), 0, size)\n            mstore(0x40, and(add(add(revertData, 0x3f), size), not(0x1f)))\n        }\n    }\n}\n"},"src/common/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\n/// @title  ReentrancyGuard\n/// @notice Declares the reentrancy guard interface without choosing where the\n///         lock lives, so one contract can be compiled against either the\n///         transient or the storage backed implementation.\n/// @dev    Mirrors the split the routers make between `ReentrancyGuardMsgSender`\n///         and `ReentrancyGuardMsgSender_NonTstore`, but as a shared base so a\n///         contract using it does not have to be duplicated per chain.\n///\n///         Semantics are the same for both implementations, and match solady's\n///         `ReentrancyGuard` including the `Reentrancy()` error selector: any\n///         reentrancy is rejected, a self call included. Guarded functions must\n///         therefore never be reachable from inside another guarded function.\n///\n///         Where the lock is kept differs between the two, so each one\n///         documents its own location. Nothing here depends on it.\nabstract contract ReentrancyGuard {\n    /// @notice Unauthorized reentrant call\n    error Reentrancy();\n\n    modifier nonReentrant() virtual;\n}\n"},"lib/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"lib/solady/src/utils/SafeTransferLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)\n///\n/// @dev Note:\n/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.\n/// - For ERC20s, this implementation won't check that a token has code,\n///   responsibility is delegated to the caller.\nlibrary SafeTransferLib {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /// @dev The ERC20 `transferFrom` has failed.\n    error TransferFromFailed();\n\n    /// @dev The ERC20 `transfer` has failed.\n    error TransferFailed();\n\n    /// @dev The ERC20 `approve` has failed.\n    error ApproveFailed();\n\n    /// @dev The Permit2 operation has failed.\n    error Permit2Failed();\n\n    /// @dev The Permit2 amount must be less than `2**160 - 1`.\n    error Permit2AmountOverflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.\n    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;\n\n    /// @dev Suggested gas stipend for contract receiving ETH to perform a few\n    /// storage reads and writes, but low enough to prevent griefing.\n    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;\n\n    /// @dev The unique EIP-712 domain domain separator for the DAI token contract.\n    bytes32 internal constant DAI_DOMAIN_SEPARATOR =\n        0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;\n\n    /// @dev The address for the WETH9 contract on Ethereum mainnet.\n    address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n    /// @dev The canonical Permit2 address.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ETH OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.\n    //\n    // The regular variants:\n    // - Forwards all remaining gas to the target.\n    // - Reverts if the target reverts.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The force variants:\n    // - Forwards with an optional gas stipend\n    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).\n    // - If the target reverts, or if the gas stipend is exhausted,\n    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.\n    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The try variants:\n    // - Forwards with a mandatory gas stipend.\n    // - Instead of reverting, returns whether the transfer succeeded.\n\n    /// @dev Sends `amount` (in wei) ETH to `to`.\n    function safeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`.\n    function safeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Transfer all the ETH and check if it succeeded or not.\n            if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      ERC20 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for\n    /// the current contract to manage.\n    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function trySafeTransferFrom(address token, address from, address to, uint256 amount)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            success :=\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have their entire balance approved for the current contract to manage.\n    function safeTransferAllFrom(address token, address from, address to)\n        internal\n        returns (uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.\n            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransfer(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransferAll(address token, address to) internal returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.\n            mstore(0x20, address()) // Store the address of the current contract.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x14, to) // Store the `to` argument.\n            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// Reverts upon failure.\n    function safeApprove(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,\n    /// then retries the approval again (some tokens, e.g. USDT, requires this).\n    /// Reverts upon failure.\n    function safeApproveWithRetry(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, retrying upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x34, 0) // Store 0 for the `amount`.\n                mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n                pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.\n                mstore(0x34, amount) // Store back the original `amount`.\n                // Retry the approval, reverting upon failure.\n                if iszero(\n                    and(\n                        or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                        call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    )\n                ) {\n                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Returns the amount of ERC20 `token` owned by `account`.\n    /// Returns zero if the `token` does not exist.\n    function balanceOf(address token, address account) internal view returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            amount :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// If the initial attempt fails, try to use Permit2 to transfer the token.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {\n        if (!trySafeTransferFrom(token, from, to, amount)) {\n            permit2TransferFrom(token, from, to, amount);\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.\n    /// Reverts upon failure.\n    function permit2TransferFrom(address token, address from, address to, uint256 amount)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(and(call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00), exists)) {\n                mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)\n            }\n        }\n    }\n\n    /// @dev Permit a user to spend a given amount of\n    /// another user's tokens via native EIP-2612 permit if possible, falling\n    /// back to Permit2 if native permit fails or is not implemented on the token.\n    function permit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            for {} shl(96, xor(token, WETH9)) {} {\n                mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.\n                if iszero(\n                    and( // The arguments of `and` are evaluated from right to left.\n                        lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.\n                        // Gas stipend to limit gas burn for tokens that don't refund gas when\n                        // an non-existing function is called. 5K should be enough for a SLOAD.\n                        staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)\n                    )\n                ) { break }\n                // After here, we can be sure that token is a contract.\n                let m := mload(0x40)\n                mstore(add(m, 0x34), spender)\n                mstore(add(m, 0x20), shl(96, owner))\n                mstore(add(m, 0x74), deadline)\n                if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {\n                    mstore(0x14, owner)\n                    mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.\n                    mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `1` is already stored at `add(m, 0x94)`.\n                    mstore(add(m, 0xb4), and(0xff, v))\n                    mstore(add(m, 0xd4), r)\n                    mstore(add(m, 0xf4), s)\n                    success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)\n                    break\n                }\n                mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.\n                mstore(add(m, 0x54), amount)\n                mstore(add(m, 0x94), and(0xff, v))\n                mstore(add(m, 0xb4), r)\n                mstore(add(m, 0xd4), s)\n                success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)\n                break\n            }\n        }\n        if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);\n    }\n\n    /// @dev Simple permit on the Permit2 contract.\n    function simplePermit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0x927da105) // `allowance(address,address,address)`.\n            {\n                let addressMask := shr(96, not(0))\n                mstore(add(m, 0x20), and(addressMask, owner))\n                mstore(add(m, 0x40), and(addressMask, token))\n                mstore(add(m, 0x60), and(addressMask, spender))\n                mstore(add(m, 0xc0), and(addressMask, spender))\n            }\n            let p := mul(PERMIT2, iszero(shr(160, amount)))\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.\n                    staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)\n                )\n            ) {\n                mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(p))), 0x04)\n            }\n            mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).\n            // `owner` is already `add(m, 0x20)`.\n            // `token` is already at `add(m, 0x40)`.\n            mstore(add(m, 0x60), amount)\n            mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.\n            // `nonce` is already at `add(m, 0xa0)`.\n            // `spender` is already at `add(m, 0xc0)`.\n            mstore(add(m, 0xe0), deadline)\n            mstore(add(m, 0x100), 0x100) // `signature` offset.\n            mstore(add(m, 0x120), 0x41) // `signature` length.\n            mstore(add(m, 0x140), r)\n            mstore(add(m, 0x160), s)\n            mstore(add(m, 0x180), shl(248, v))\n            if iszero(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":["@openzeppelin/=lib/openzeppelin-contracts/","solady/=lib/solady/","permit2-relay/=lib/permit2-relay/","0x-settler/=lib/0x-settler/","trustlessPermit/=lib/trustlessPermit/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/","lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/","lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/","lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/","lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/","lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/","lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/","lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/","lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/","lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/","lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/","lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/","lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/","lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/","lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/","lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/","lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/","lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/","lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/","lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/","lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/","lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/","lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/","lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/","lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/","lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/","ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/","permit2/=lib/0x-settler/lib/permit2/","solmate/=lib/0x-settler/lib/solmate/"]},"name":"RouteRacer","fullyQualifiedName":"src/route-racer/RouteRacer.sol:RouteRacer"},"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AllRoutesFailed","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ExcessiveRouteValue","type":"error","inputs":[]},{"name":"IdenticalTokens","type":"error","inputs":[]},{"name":"InsufficientOutput","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"}]},{"name":"InvalidMainCount","type":"error","inputs":[{"name":"mainCount","type":"uint256","internalType":"uint256"},{"name":"routeCount","type":"uint256","internalType":"uint256"}]},{"name":"InvalidMsgValue","type":"error","inputs":[]},{"name":"InvalidRecipient","type":"error","inputs":[{"name":"recipient","type":"address","internalType":"address"}]},{"name":"InvalidRouteFee","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"}]},{"name":"InvalidRouteTarget","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"MinAmountOutRequired","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NoRoutes","type":"error","inputs":[]},{"name":"OnlySelf","type":"error","inputs":[]},{"name":"RecipientCannotBeZeroAddress","type":"error","inputs":[]},{"name":"Reentrancy","type":"error","inputs":[]},{"name":"RefundToCannotBeZeroAddress","type":"error","inputs":[]},{"name":"RouteApprovalFailed","type":"error","inputs":[]},{"name":"RouteGasLimitRequired","type":"error","inputs":[]},{"name":"TrialResult","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"ValueOnNativeOutput","type":"error","inputs":[]},{"name":"WinnerUnderperformed","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"trialAmountOut","type":"uint256","internalType":"uint256"}]},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RouteExecutionFailed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"revertData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteRaceWon","type":"event","inputs":[{"name":"index","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"trialedCount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mainCount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"metadata","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteTrialFailed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"revertData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteTrialSucceeded","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FEE_DENOMINATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"callRoute","type":"function","inputs":[],"outputs":[{"name":"output","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"race","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"tokenOut","type":"address","internalType":"address"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"refundTo","type":"address","internalType":"address"},{"name":"routes","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"gasLimit","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"}],"internalType":"struct Route[]"},{"name":"emitEvents","type":"bool","internalType":"bool"},{"name":"metadata","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"winnerIndex","type":"uint256","internalType":"uint256"},{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"raceWithBackups","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"tokenOut","type":"address","internalType":"address"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"refundTo","type":"address","internalType":"address"},{"name":"routes","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"gasLimit","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"}],"internalType":"struct Route[]"},{"name":"mainCount","type":"uint256","internalType":"uint256"},{"name":"emitEvents","type":"bool","internalType":"bool"},{"name":"metadata","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"winnerIndex","type":"uint256","internalType":"uint256"},{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"withdraw","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AllRoutesFailed","type":"error"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"ExcessiveRouteValue","type":"error"},{"inputs":[],"name":"IdenticalTokens","type":"error"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"}],"name":"InsufficientOutput","type":"error"},{"inputs":[{"internalType":"uint256","name":"mainCount","type":"uint256"},{"internalType":"uint256","name":"routeCount","type":"uint256"}],"name":"InvalidMainCount","type":"error"},{"inputs":[],"name":"InvalidMsgValue","type":"error"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"InvalidRecipient","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"feePpm","type":"uint256"}],"name":"InvalidRouteFee","type":"error"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"InvalidRouteTarget","type":"error"},{"inputs":[],"name":"MinAmountOutRequired","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"NoRoutes","type":"error"},{"inputs":[],"name":"OnlySelf","type":"error"},{"inputs":[],"name":"RecipientCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"Reentrancy","type":"error"},{"inputs":[],"name":"RefundToCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"RouteApprovalFailed","type":"error"},{"inputs":[],"name":"RouteGasLimitRequired","type":"error"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"TrialResult","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"inputs":[],"name":"ValueOnNativeOutput","type":"error"},{"inputs":[{"internalType":"uint256","name":"amountOut","type":"uint256"},{"internalType":"uint256","name":"trialAmountOut","type":"uint256"}],"name":"WinnerUnderperformed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bytes","name":"revertData","type":"bytes"}],"name":"RouteExecutionFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"trialedCount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mainCount","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"RouteRaceWon","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bytes","name":"revertData","type":"bytes"}],"name":"RouteTrialFailed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"index","type":"uint256"},{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"uint256","name":"amountOut","type":"uint256"}],"name":"RouteTrialSucceeded","type":"event"},{"inputs":[],"name":"FEE_DENOMINATOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"callRoute","outputs":[{"internalType":"uint256","name":"output","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"refundTo","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"feePpm","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Route[]","name":"routes","type":"tuple[]"},{"internalType":"bool","name":"emitEvents","type":"bool"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"race","outputs":[{"internalType":"uint256","name":"winnerIndex","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenIn","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"address","name":"tokenOut","type":"address"},{"internalType":"uint256","name":"minAmountOut","type":"uint256"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"address","name":"refundTo","type":"address"},{"components":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"gasLimit","type":"uint256"},{"internalType":"uint256","name":"feePpm","type":"uint256"},{"internalType":"bytes","name":"callData","type":"bytes"}],"internalType":"struct Route[]","name":"routes","type":"tuple[]"},{"internalType":"uint256","name":"mainCount","type":"uint256"},{"internalType":"bool","name":"emitEvents","type":"bool"},{"internalType":"bytes","name":"metadata","type":"bytes"}],"name":"raceWithBackups","outputs":[{"internalType":"uint256","name":"winnerIndex","type":"uint256"},{"internalType":"uint256","name":"amountOut","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"details":"The default. Requires Cancun; use `RouteRacer_NonTstore` on chains         without transient storage.","errors":{"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"Unauthorized()":[{"details":"The caller is not authorized to call the function."}]},"events":{"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"RouteExecutionFailed(uint256,address,bytes)":{"params":{"index":"The index of the failed route in `routes`, where anything        at or above the race's `mainCount` is a backup","revertData":"The (truncated) revert data of the failed execution","target":"The swap provider router that was called"}},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"params":{"amountOut":"The actual executed output delivered to the recipient","index":"The index of the winning route in `routes`, where        anything at or above the race's `mainCount` is a backup","mainCount":"How many of `routes` were mains: `routes.length` on        `race`, the caller's `mainCount` on `raceWithBackups`. With it        the event alone tells a rescue (`index >= mainCount`) from a        main's win and whether the backups ran at all (`trialedCount >        mainCount`), without reading the race calldata","metadata":"Additional data to associate the race to","target":"The swap provider router of the winning route","trialedCount":"How many candidates were actually trialed, always a        prefix of `routes`. Equals `mainCount` when the mains filled the        race and the backups were never reached, so a consumer can tell        a skipped candidate from a failed one instead of undercounting        from the trial events"}},"RouteTrialFailed(uint256,address,bytes)":{"params":{"index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup","revertData":"The (truncated) revert data of the failed trial","target":"The swap provider router that was called"}},"RouteTrialSucceeded(uint256,address,uint256)":{"params":{"amountOut":"The measured output of the trial","index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup. A backup that the race        never reached emits nothing, so use `trialedCount` on        `RouteRaceWon` rather than counting these events to know how        many candidates were tried. Not indexed: a consumer filters by        race transaction, never by route index, and the topic cost more        than the data word","target":"The swap provider router that was called"}}},"kind":"dev","methods":{"callRoute()":{"details":"Only callable by this contract itself (via `_callRoute`), which         is load bearing: the balance snapshot is an input, so a forged         snapshot of zero would report the contract's whole `tokenOut`         balance as one route's output. Takes no ABI arguments:         `_callRoute` writes a fixed layout payload after the selector         and this reads it back at the same offsets (GAS.md step 18).         Layout, offsets from the start of calldata:           0x004  isTrial           0x024  threshold (commit threshold for a trial, the trial                  claimed output for the winner)           0x044  tokenIn           0x064  amountIn           0x084  tokenOut           0x0a4  outBalanceBefore           0x0c4  target, spender, value, gasLimit (the route head)           0x144  callData length           0x164  callData bytes"},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"owner()":{"details":"Returns the owner of the contract."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"details":"The caller must have approved this contract for `amountIn` of         `tokenIn` (or send it as msg.value when `tokenIn` is native).         Swap calldata must be built with this contract as taker/recipient         so outputs land here and can be measured. Among the routes         whose raw output clears `minAmountOut` the one with the         highest output net of its `feePpm` wins; a route below the         floor never wins over one that clears it, whatever its net.         The last candidate keeps its own execution when its raw         output already matches every earlier trial net of fees and         clears the floor, which fills the race without a second         execution, so order candidates worst to best by expected net         output to hit that path. Among the other candidates an exact         tie on net output goes to the route whose trial used less         gas, not to the earlier one. Otherwise candidates are         executed in descending net output order: an execution that         fails or delivers less than its trial output is rolled back         and the next-best route is tried instead. Reverts if every         route fails, no trial output clears `minAmountOut`, or every         candidate's execution fails. Leftover native and unspent         input tokens are refunded to `refundTo`.         Every route here is a main: all of them are trialed. To hold         some routes back as backups, call `raceWithBackups`.","params":{"amountIn":"The input amount","emitEvents":"Whether to emit per-trial and winner events","metadata":"Additional data to associate the race to","minAmountOut":"The minimum acceptable executed output (must be > 0)","recipient":"The address to receive the winning output","refundTo":"The address to refund any leftover funds to","routes":"The candidate swap routes to race. Must not be empty","tokenIn":"The input token (address(0) for native)","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)"},"returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route"}},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"details":"Identical to `race` except that only the first `mainCount`         routes are trialed up front. The rest are reached only when         the mains leave the race unfillable, meaning none of them         succeeded, the best of them is below `minAmountOut`, or every         main that cleared it failed its real execution, so a race         whose mains fill never pays to trial a backup. A backup         is a guard against a main failing, not against a main being         mispriced: a main that clears the floor wins even where a         backup would have paid more. Backups are not raced against         each other either: they are trialed in order and the first         that clears `minAmountOut` is executed, as its trial, so order         them most reliable first. Both lists share one index space,         mains first, so any index at or above `mainCount` is a backup.","params":{"amountIn":"The input amount","emitEvents":"Whether to emit per-trial and winner events","mainCount":"How many of `routes` are mains. Must be nonzero and no        greater than `routes.length`; equal to it means no backups,        which is exactly `race`. The rest are tried in order until one        clears the floor","metadata":"Additional data to associate the race to","minAmountOut":"The minimum acceptable executed output (must be > 0).        This is doing double duty: it is both the caller's protection        floor and the trigger for the backup routes, which are only        trialed when the mains cannot clear it. Raising it therefore        makes backups fire more often and also makes more fills revert,        so choose it with both effects in mind","recipient":"The address to receive the winning output","refundTo":"The address to refund any leftover funds to","routes":"Every candidate, mains first then the backups. Must not        be empty","tokenIn":"The input token (address(0) for native)","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)"},"returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route in `routes`, where         anything at or above `mainCount` is a backup"}},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"withdraw(address,address)":{"details":"Sweeps the whole balance. `onlyOwner`, so naming a recipient         grants nothing the owner could not already do by withdrawing to         themselves and transferring on; it only saves that second step","params":{"to":"The address to send it to","token":"The token to sweep, or address(0) for the native balance"}}},"title":"RouteRacer","version":1},"userdoc":{"errors":{"AllRoutesFailed()":[{"notice":"Revert if every route's trial failed"}],"ExcessiveRouteValue()":[{"notice":"Recorded as a route's trial failure reason when its `value`         exceeds the native value provided by the caller for this fill"}],"IdenticalTokens()":[{"notice":"Revert if `tokenIn` and `tokenOut` are the same token, which         would break the balance-delta output measurement"}],"InsufficientOutput(uint256,uint256)":[{"notice":"Revert if the best trial output is below the minimum"}],"InvalidMainCount(uint256,uint256)":[{"notice":"Revert if `mainCount` is zero, which would trial nothing, or         exceeds the number of routes supplied"}],"InvalidMsgValue()":[{"notice":"Revert if msg.value does not cover a native `amountIn`"}],"InvalidRecipient(address)":[{"notice":"Revert if the recipient is this contract"}],"InvalidRouteFee(uint256,uint256)":[{"notice":"Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.         A fee of the whole output leaves nothing to rank and would         divide by zero in the commit threshold"}],"InvalidRouteTarget(address)":[{"notice":"Revert if a route targets this contract, which would make the         contract its own caller and satisfy the `OnlySelf` gate on         `callRoute`"}],"MinAmountOutRequired()":[{"notice":"Revert if `minAmountOut` is zero, which would disable the theft guard"}],"NoRoutes()":[{"notice":"Revert if no routes are provided"}],"OnlySelf()":[{"notice":"Revert if `callRoute` is called by anyone other than this contract"}],"RecipientCannotBeZeroAddress()":[{"notice":"Revert if a recipient is the zero address, either the race's         `recipient` or a `withdraw` destination"}],"Reentrancy()":[{"notice":"Unauthorized reentrant call"}],"RefundToCannotBeZeroAddress()":[{"notice":"Revert if the refundTo address is the zero address"}],"RouteApprovalFailed()":[{"notice":"Recorded as a route's trial failure reason when `tokenIn`         cannot be approved for the route's spender"}],"RouteGasLimitRequired()":[{"notice":"Revert if a route's `gasLimit` is zero, which would let it         starve the other trials and the winner's execution"}],"TrialResult(uint256)":[{"notice":"Used as the success signal of a trial subcall, never a real failure"}],"ValueOnNativeOutput()":[{"notice":"Recorded as a route's trial failure reason when the output is         native and the route would forward native value. Output is         measured as this contract's native balance delta, so any of         that value the provider hands back would count as swap output:         a refunded fee would go to the recipient instead of `refundTo`,         `minAmountOut` would stop being a guarantee, and a route that         simply returned what it was given could beat one that swaps"}],"WinnerUnderperformed(uint256,uint256)":[{"notice":"Revert if the winner's executed output is below its trial-claimed output"}]},"events":{"RouteExecutionFailed(uint256,address,bytes)":{"notice":"Emitted when a selected route's real execution fails or         under-delivers and is rolled back, before the race falls back         to the next-best route (when `emitEvents` is set)"},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"notice":"Emitted after the winning route is executed (when `emitEvents` is set)"},"RouteTrialFailed(uint256,address,bytes)":{"notice":"Emitted for each route trial that failed (when `emitEvents` is         set)"},"RouteTrialSucceeded(uint256,address,uint256)":{"notice":"Emitted for each route trial that succeeded (when `emitEvents`         is set)"}},"kind":"user","methods":{"FEE_DENOMINATOR()":{"notice":"The unit of `Route.feePpm`: a fee of this many parts is the         whole output. Parts per million, so a basis point is 100 and         a deal quoted in fractions of a basis point still fits"},"callRoute()":{"notice":"Run one route in its own call frame and measure its output.         A trial reverts with `TrialResult(output)` so that everything         the route did is discarded, unless the output clears the commit         threshold, in which case the frame returns the output and keeps         the execution. The winner's execution returns its output when         that is at least the trial's claim and reverts with         `WinnerUnderperformed` otherwise, so the race can roll it back"},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"notice":"Pull `amountIn` of `tokenIn` from the caller, trial every route,         execute the one with the highest output net of its fee and         deliver its raw output of `tokenOut` to `recipient`"},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"notice":"`race`, with the tail of `routes` held back as backups that are         trialed only when the mains cannot fill the order"},"withdraw(address,address)":{"notice":"Withdraw funds that got stuck in the contract"}},"notice":"`RouteRacerBase` with the reentrancy lock in transient storage.","version":1}},"settings":{"compilationTarget":{"src/route-racer/RouteRacer.sol":"RouteRacer"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[":0x-settler/=lib/0x-settler/",":@openzeppelin/=lib/openzeppelin-contracts/",":ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/",":forge-std/=lib/forge-std/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/",":permit2-relay/=lib/permit2-relay/",":permit2/=lib/0x-settler/lib/permit2/",":solady/=lib/solady/",":solmate/=lib/0x-settler/lib/solmate/",":trustlessPermit/=lib/trustlessPermit/","lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/","lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/","lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/","lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/","lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/","lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/","lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/","lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/","lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/","lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/","lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/","lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/","lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/"],"viaIR":true},"sources":{"lib/solady/src/auth/Ownable.sol":{"keccak256":"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3","license":"MIT","urls":["bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3","dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs"]},"lib/solady/src/utils/SafeTransferLib.sol":{"keccak256":"0x583f47701d9b47bb3ef80fcabbbd62fbb58a01733b7a57e19658b4b02468883a","license":"MIT","urls":["bzz-raw://2523bfac005e21ef9963fdb3c08b2c61824e2b5ce2f53d1a1828b01ed995217c","dweb:/ipfs/QmbBjVG9tZyeZSQH4m5GUzNBwo2iuvLoZYbmhT4gxnJc4J"]},"src/common/ReentrancyGuard.sol":{"keccak256":"0xa692f06a785ef1ad64199597777c89af8398a175565c2d93c13a75d712ae574d","license":"MIT","urls":["bzz-raw://eb998af38f7c17a16a9b201065cf34c14c6a148537a35c03f1119f1d02069b74","dweb:/ipfs/QmWnK6SaWS28yCmvwg5THsmqcPfRf8shQaystVX3XZqUVe"]},"src/common/ReentrancyGuardTransient.sol":{"keccak256":"0x8485fb154198103d4b3f0a0ab0106d81a4d109cef1e3ebf37f67556b65de0382","license":"MIT","urls":["bzz-raw://b26d695069d749b12730659fb2fd9230dcd0d8371851dab0f34eb0e78f52c265","dweb:/ipfs/QmUz4jdb28vdD9722UKuDWEHB9ah4H2FuDKAL4yF88gk5x"]},"src/route-racer/RouteRacer.sol":{"keccak256":"0xd171e03eb79a155499efb4a15acc5631c2333d5ed1fefef660609199c1824745","license":"MIT","urls":["bzz-raw://57dc8d8da385b2e56168b82a1d71d84d2ba9147b6a7f74044f686135bf723878","dweb:/ipfs/QmTzFQyNpn64CPYyCwZG2fzqwpXe2CogHcurNUrjteGWhu"]},"src/route-racer/RouteRacerBase.sol":{"keccak256":"0xddbc9e663e03d77fa87c7ea7368931798649e8e5305c078e23a681d8966439b9","license":"MIT","urls":["bzz-raw://546b1dd1eb51e299d248c3957ff211cbcff527ffa7cea180a659eef70abac28e","dweb:/ipfs/QmaXdqFdKjWasbYa3z17ng3Vbpv8SPpnfRmVKkGNXvFrbw"]}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":{"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":545,"label":"_locked","offset":0,"contract":"src/route-racer/RouteRacer.sol:RouteRacer"}]},"userdoc":{"kind":"user","errors":{"NoRoutes()":[{"notice":"Revert if no routes are provided"}],"OnlySelf()":[{"notice":"Revert if `callRoute` is called by anyone other than this contract"}],"Reentrancy()":[{"notice":"Unauthorized reentrant call"}],"AllRoutesFailed()":[{"notice":"Revert if every route's trial failed"}],"IdenticalTokens()":[{"notice":"Revert if `tokenIn` and `tokenOut` are the same token, which         would break the balance-delta output measurement"}],"InvalidMsgValue()":[{"notice":"Revert if msg.value does not cover a native `amountIn`"}],"TrialResult(uint256)":[{"notice":"Used as the success signal of a trial subcall, never a real failure"}],"ExcessiveRouteValue()":[{"notice":"Recorded as a route's trial failure reason when its `value`         exceeds the native value provided by the caller for this fill"}],"RouteApprovalFailed()":[{"notice":"Recorded as a route's trial failure reason when `tokenIn`         cannot be approved for the route's spender"}],"ValueOnNativeOutput()":[{"notice":"Recorded as a route's trial failure reason when the output is         native and the route would forward native value. Output is         measured as this contract's native balance delta, so any of         that value the provider hands back would count as swap output:         a refunded fee would go to the recipient instead of `refundTo`,         `minAmountOut` would stop being a guarantee, and a route that         simply returned what it was given could beat one that swaps"}],"MinAmountOutRequired()":[{"notice":"Revert if `minAmountOut` is zero, which would disable the theft guard"}],"RouteGasLimitRequired()":[{"notice":"Revert if a route's `gasLimit` is zero, which would let it         starve the other trials and the winner's execution"}],"InvalidRecipient(address)":[{"notice":"Revert if the recipient is this contract"}],"InvalidRouteTarget(address)":[{"notice":"Revert if a route targets this contract, which would make the         contract its own caller and satisfy the `OnlySelf` gate on         `callRoute`"}],"RefundToCannotBeZeroAddress()":[{"notice":"Revert if the refundTo address is the zero address"}],"RecipientCannotBeZeroAddress()":[{"notice":"Revert if a recipient is the zero address, either the race's         `recipient` or a `withdraw` destination"}],"InvalidRouteFee(uint256,uint256)":[{"notice":"Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.         A fee of the whole output leaves nothing to rank and would         divide by zero in the commit threshold"}],"InvalidMainCount(uint256,uint256)":[{"notice":"Revert if `mainCount` is zero, which would trial nothing, or         exceeds the number of routes supplied"}],"InsufficientOutput(uint256,uint256)":[{"notice":"Revert if the best trial output is below the minimum"}],"WinnerUnderperformed(uint256,uint256)":[{"notice":"Revert if the winner's executed output is below its trial-claimed output"}]},"events":{"RouteTrialFailed(uint256,address,bytes)":{"notice":"Emitted for each route trial that failed (when `emitEvents` is         set)"},"RouteExecutionFailed(uint256,address,bytes)":{"notice":"Emitted when a selected route's real execution fails or         under-delivers and is rolled back, before the race falls back         to the next-best route (when `emitEvents` is set)"},"RouteTrialSucceeded(uint256,address,uint256)":{"notice":"Emitted for each route trial that succeeded (when `emitEvents`         is set)"},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"notice":"Emitted after the winning route is executed (when `emitEvents` is set)"}},"notice":"`RouteRacerBase` with the reentrancy lock in transient storage.","methods":{"callRoute()":{"notice":"Run one route in its own call frame and measure its output.         A trial reverts with `TrialResult(output)` so that everything         the route did is discarded, unless the output clears the commit         threshold, in which case the frame returns the output and keeps         the execution. The winner's execution returns its output when         that is at least the trial's claim and reverts with         `WinnerUnderperformed` otherwise, so the race can roll it back"},"FEE_DENOMINATOR()":{"notice":"The unit of `Route.feePpm`: a fee of this many parts is the         whole output. Parts per million, so a basis point is 100 and         a deal quoted in fractions of a basis point still fits"},"withdraw(address,address)":{"notice":"Withdraw funds that got stuck in the contract"},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"notice":"Pull `amountIn` of `tokenIn` from the caller, trial every route,         execute the one with the highest output net of its fee and         deliver its raw output of `tokenOut` to `recipient`"},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"notice":"`race`, with the tail of `routes` held back as backups that are         trialed only when the mains cannot fill the order"}},"version":1},"devdoc":{"kind":"dev","title":"RouteRacer","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}]},"events":{"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"RouteTrialFailed(uint256,address,bytes)":{"params":{"index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup","target":"The swap provider router that was called","revertData":"The (truncated) revert data of the failed trial"}},"RouteExecutionFailed(uint256,address,bytes)":{"params":{"index":"The index of the failed route in `routes`, where anything        at or above the race's `mainCount` is a backup","target":"The swap provider router that was called","revertData":"The (truncated) revert data of the failed execution"}},"RouteTrialSucceeded(uint256,address,uint256)":{"params":{"index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup. A backup that the race        never reached emits nothing, so use `trialedCount` on        `RouteRaceWon` rather than counting these events to know how        many candidates were tried. Not indexed: a consumer filters by        race transaction, never by route index, and the topic cost more        than the data word","target":"The swap provider router that was called","amountOut":"The measured output of the trial"}},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"params":{"index":"The index of the winning route in `routes`, where        anything at or above the race's `mainCount` is a backup","target":"The swap provider router of the winning route","metadata":"Additional data to associate the race to","amountOut":"The actual executed output delivered to the recipient","mainCount":"How many of `routes` were mains: `routes.length` on        `race`, the caller's `mainCount` on `raceWithBackups`. With it        the event alone tells a rescue (`index >= mainCount`) from a        main's win and whether the backups ran at all (`trialedCount >        mainCount`), without reading the race calldata","trialedCount":"How many candidates were actually trialed, always a        prefix of `routes`. Equals `mainCount` when the mains filled the        race and the backups were never reached, so a consumer can tell        a skipped candidate from a failed one instead of undercounting        from the trial events"}}},"details":"The default. Requires Cancun; use `RouteRacer_NonTstore` on chains         without transient storage.","methods":{"owner()":{"details":"Returns the owner of the contract."},"callRoute()":{"details":"Only callable by this contract itself (via `_callRoute`), which         is load bearing: the balance snapshot is an input, so a forged         snapshot of zero would report the contract's whole `tokenOut`         balance as one route's output. Takes no ABI arguments:         `_callRoute` writes a fixed layout payload after the selector         and this reads it back at the same offsets (GAS.md step 18).         Layout, offsets from the start of calldata:           0x004  isTrial           0x024  threshold (commit threshold for a trial, the trial                  claimed output for the winner)           0x044  tokenIn           0x064  amountIn           0x084  tokenOut           0x0a4  outBalanceBefore           0x0c4  target, spender, value, gasLimit (the route head)           0x144  callData length           0x164  callData bytes"},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"withdraw(address,address)":{"params":{"to":"The address to send it to","token":"The token to sweep, or address(0) for the native balance"},"details":"Sweeps the whole balance. `onlyOwner`, so naming a recipient         grants nothing the owner could not already do by withdrawing to         themselves and transferring on; it only saves that second step"},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"params":{"routes":"The candidate swap routes to race. Must not be empty","tokenIn":"The input token (address(0) for native)","amountIn":"The input amount","metadata":"Additional data to associate the race to","refundTo":"The address to refund any leftover funds to","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)","recipient":"The address to receive the winning output","emitEvents":"Whether to emit per-trial and winner events","minAmountOut":"The minimum acceptable executed output (must be > 0)"},"details":"The caller must have approved this contract for `amountIn` of         `tokenIn` (or send it as msg.value when `tokenIn` is native).         Swap calldata must be built with this contract as taker/recipient         so outputs land here and can be measured. Among the routes         whose raw output clears `minAmountOut` the one with the         highest output net of its `feePpm` wins; a route below the         floor never wins over one that clears it, whatever its net.         The last candidate keeps its own execution when its raw         output already matches every earlier trial net of fees and         clears the floor, which fills the race without a second         execution, so order candidates worst to best by expected net         output to hit that path. Among the other candidates an exact         tie on net output goes to the route whose trial used less         gas, not to the earlier one. Otherwise candidates are         executed in descending net output order: an execution that         fails or delivers less than its trial output is rolled back         and the next-best route is tried instead. Reverts if every         route fails, no trial output clears `minAmountOut`, or every         candidate's execution fails. Leftover native and unspent         input tokens are refunded to `refundTo`.         Every route here is a main: all of them are trialed. To hold         some routes back as backups, call `raceWithBackups`.","returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route"}},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"params":{"routes":"Every candidate, mains first then the backups. Must not        be empty","tokenIn":"The input token (address(0) for native)","amountIn":"The input amount","metadata":"Additional data to associate the race to","refundTo":"The address to refund any leftover funds to","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)","mainCount":"How many of `routes` are mains. Must be nonzero and no        greater than `routes.length`; equal to it means no backups,        which is exactly `race`. The rest are tried in order until one        clears the floor","recipient":"The address to receive the winning output","emitEvents":"Whether to emit per-trial and winner events","minAmountOut":"The minimum acceptable executed output (must be > 0).        This is doing double duty: it is both the caller's protection        floor and the trigger for the backup routes, which are only        trialed when the mains cannot clear it. Raising it therefore        makes backups fire more often and also makes more fills revert,        so choose it with both effects in mind"},"details":"Identical to `race` except that only the first `mainCount`         routes are trialed up front. The rest are reached only when         the mains leave the race unfillable, meaning none of them         succeeded, the best of them is below `minAmountOut`, or every         main that cleared it failed its real execution, so a race         whose mains fill never pays to trial a backup. A backup         is a guard against a main failing, not against a main being         mispriced: a main that clears the floor wins even where a         backup would have paid more. Backups are not raced against         each other either: they are trialed in order and the first         that clears `minAmountOut` is executed, as its trial, so order         them most reliable first. Both lists share one index space,         mains first, so any index at or above `mainCount` is a backup.","returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route in `routes`, where         anything at or above `mainCount` is a backup"}}},"version":1},"sourceIds":{"src/common/ReentrancyGuard.sol":{"id":2},"src/route-racer/RouteRacer.sol":{"id":4},"lib/solady/src/auth/Ownable.sol":{"id":0},"src/route-racer/RouteRacerBase.sol":{"id":5},"src/common/ReentrancyGuardTransient.sol":{"id":3},"lib/solady/src/utils/SafeTransferLib.sol":{"id":1}},"additionalInput":null,"stdJsonInput":{"sources":{"src/common/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\n/// @title  ReentrancyGuard\n/// @notice Declares the reentrancy guard interface without choosing where the\n///         lock lives, so one contract can be compiled against either the\n///         transient or the storage backed implementation.\n/// @dev    Mirrors the split the routers make between `ReentrancyGuardMsgSender`\n///         and `ReentrancyGuardMsgSender_NonTstore`, but as a shared base so a\n///         contract using it does not have to be duplicated per chain.\n///\n///         Semantics are the same for both implementations, and match solady's\n///         `ReentrancyGuard` including the `Reentrancy()` error selector: any\n///         reentrancy is rejected, a self call included. Guarded functions must\n///         therefore never be reachable from inside another guarded function.\n///\n///         Where the lock is kept differs between the two, so each one\n///         documents its own location. Nothing here depends on it.\nabstract contract ReentrancyGuard {\n    /// @notice Unauthorized reentrant call\n    error Reentrancy();\n\n    modifier nonReentrant() virtual;\n}\n"},"src/route-racer/RouteRacer.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\nimport {ReentrancyGuardTransient} from \"../common/ReentrancyGuardTransient.sol\";\n\nimport {RouteRacerBase} from \"./RouteRacerBase.sol\";\n\n/// @title  RouteRacer\n/// @notice `RouteRacerBase` with the reentrancy lock in transient storage.\n/// @dev    The default. Requires Cancun; use `RouteRacer_NonTstore` on chains\n///         without transient storage.\ncontract RouteRacer is RouteRacerBase, ReentrancyGuardTransient {\n    constructor(address _owner) RouteRacerBase(_owner) {}\n}\n"},"lib/solady/src/auth/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Simple single owner authorization mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)\n///\n/// @dev Note:\n/// This implementation does NOT auto-initialize the owner to `msg.sender`.\n/// You MUST call the `_initializeOwner` in the constructor / initializer.\n///\n/// While the ownable portion follows\n/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,\n/// the nomenclature for the 2-step ownership handover may be unique to this codebase.\nabstract contract Ownable {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The caller is not authorized to call the function.\n    error Unauthorized();\n\n    /// @dev The `newOwner` cannot be the zero address.\n    error NewOwnerIsZeroAddress();\n\n    /// @dev The `pendingOwner` does not have a valid handover request.\n    error NoHandoverRequest();\n\n    /// @dev Cannot double-initialize.\n    error AlreadyInitialized();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                           EVENTS                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.\n    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be\n    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),\n    /// despite it not being as lightweight as a single argument event.\n    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);\n\n    /// @dev An ownership handover to `pendingOwner` has been requested.\n    event OwnershipHandoverRequested(address indexed pendingOwner);\n\n    /// @dev The ownership handover to `pendingOwner` has been canceled.\n    event OwnershipHandoverCanceled(address indexed pendingOwner);\n\n    /// @dev `keccak256(bytes(\"OwnershipTransferred(address,address)\"))`.\n    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =\n        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverRequested(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =\n        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;\n\n    /// @dev `keccak256(bytes(\"OwnershipHandoverCanceled(address)\"))`.\n    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =\n        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The owner slot is given by:\n    /// `bytes32(~uint256(uint32(bytes4(keccak256(\"_OWNER_SLOT_NOT\")))))`.\n    /// It is intentionally chosen to be a high value\n    /// to avoid collision with lower slots.\n    /// The choice of manual storage layout is to enable compatibility\n    /// with both regular and upgradeable contracts.\n    bytes32 internal constant _OWNER_SLOT =\n        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;\n\n    /// The ownership handover slot of `newOwner` is given by:\n    /// ```\n    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))\n    ///     let handoverSlot := keccak256(0x00, 0x20)\n    /// ```\n    /// It stores the expiry timestamp of the two-step ownership handover.\n    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                     INTERNAL FUNCTIONS                     */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.\n    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}\n\n    /// @dev Initializes the owner directly without authorization guard.\n    /// This function must be called upon initialization,\n    /// regardless of whether the contract is upgradeable or not.\n    /// This is to enable generalization to both regular and upgradeable contracts,\n    /// and to save gas in case the initial owner is not the caller.\n    /// For performance reasons, this function will not check if there\n    /// is an existing owner.\n    function _initializeOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                if sload(ownerSlot) {\n                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.\n                    revert(0x1c, 0x04)\n                }\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Store the new value.\n                sstore(_OWNER_SLOT, newOwner)\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)\n            }\n        }\n    }\n\n    /// @dev Sets the owner directly without authorization guard.\n    function _setOwner(address newOwner) internal virtual {\n        if (_guardInitializeOwner()) {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))\n            }\n        } else {\n            /// @solidity memory-safe-assembly\n            assembly {\n                let ownerSlot := _OWNER_SLOT\n                // Clean the upper 96 bits.\n                newOwner := shr(96, shl(96, newOwner))\n                // Emit the {OwnershipTransferred} event.\n                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)\n                // Store the new value.\n                sstore(ownerSlot, newOwner)\n            }\n        }\n    }\n\n    /// @dev Throws if the sender is not the owner.\n    function _checkOwner() internal view virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // If the caller is not the stored owner, revert.\n            if iszero(eq(caller(), sload(_OWNER_SLOT))) {\n                mstore(0x00, 0x82b42900) // `Unauthorized()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Returns how long a two-step ownership handover is valid for in seconds.\n    /// Override to return a different value if needed.\n    /// Made internal to conserve bytecode. Wrap it in a public function if needed.\n    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {\n        return 48 * 3600;\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                  PUBLIC UPDATE FUNCTIONS                   */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Allows the owner to transfer the ownership to `newOwner`.\n    function transferOwnership(address newOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(shl(96, newOwner)) {\n                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.\n                revert(0x1c, 0x04)\n            }\n        }\n        _setOwner(newOwner);\n    }\n\n    /// @dev Allows the owner to renounce their ownership.\n    function renounceOwnership() public payable virtual onlyOwner {\n        _setOwner(address(0));\n    }\n\n    /// @dev Request a two-step ownership handover to the caller.\n    /// The request will automatically expire in 48 hours (172800 seconds) by default.\n    function requestOwnershipHandover() public payable virtual {\n        unchecked {\n            uint256 expires = block.timestamp + _ownershipHandoverValidFor();\n            /// @solidity memory-safe-assembly\n            assembly {\n                // Compute and set the handover slot to `expires`.\n                mstore(0x0c, _HANDOVER_SLOT_SEED)\n                mstore(0x00, caller())\n                sstore(keccak256(0x0c, 0x20), expires)\n                // Emit the {OwnershipHandoverRequested} event.\n                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())\n            }\n        }\n    }\n\n    /// @dev Cancels the two-step ownership handover to the caller, if any.\n    function cancelOwnershipHandover() public payable virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, caller())\n            sstore(keccak256(0x0c, 0x20), 0)\n            // Emit the {OwnershipHandoverCanceled} event.\n            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())\n        }\n    }\n\n    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.\n    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.\n    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute and set the handover slot to 0.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            let handoverSlot := keccak256(0x0c, 0x20)\n            // If the handover does not exist, or has expired.\n            if gt(timestamp(), sload(handoverSlot)) {\n                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.\n                revert(0x1c, 0x04)\n            }\n            // Set the handover slot to 0.\n            sstore(handoverSlot, 0)\n        }\n        _setOwner(pendingOwner);\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                   PUBLIC READ FUNCTIONS                    */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Returns the owner of the contract.\n    function owner() public view virtual returns (address result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            result := sload(_OWNER_SLOT)\n        }\n    }\n\n    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\n    function ownershipHandoverExpiresAt(address pendingOwner)\n        public\n        view\n        virtual\n        returns (uint256 result)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Compute the handover slot.\n            mstore(0x0c, _HANDOVER_SLOT_SEED)\n            mstore(0x00, pendingOwner)\n            // Load the handover slot.\n            result := sload(keccak256(0x0c, 0x20))\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         MODIFIERS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Marks a function as only callable by the owner.\n    modifier onlyOwner() virtual {\n        _checkOwner();\n        _;\n    }\n}\n"},"src/route-racer/RouteRacerBase.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.25;\n\nimport {Ownable} from \"solady/src/auth/Ownable.sol\";\nimport {SafeTransferLib} from \"solady/src/utils/SafeTransferLib.sol\";\n\nimport {ReentrancyGuard} from \"../common/ReentrancyGuard.sol\";\n\n/// @notice A single candidate swap route to race\n/// @param target The swap provider router to call\n/// @param spender The address to approve for spending `tokenIn` (ignored when `tokenIn` is native)\n/// @param value The native value to forward with the call\n/// @param gasLimit The max gas made available to this route's trial and its\n///        real execution (must be nonzero so one route can never starve the\n///        other trials or the winner's execution; the EVM caps the forwarded\n///        amount at 63/64 of the remaining gas, so a deliberately high value\n///        effectively forwards all available gas)\n/// @param feePpm The fee the provider behind this route charges the caller\n///        on its output, in parts per million (100 is one basis point).\n///        Only steers the choice of winner: routes are ranked by output net\n///        of this fee, while the output delivered, the floor and the events\n///        stay raw. Zero means no fee; must be below `FEE_DENOMINATOR`\n/// @param callData The swap calldata to execute against `target`\nstruct Route {\n    address target;\n    address spender;\n    uint256 value;\n    uint256 gasLimit;\n    uint256 feePpm;\n    bytes callData;\n}\n\n/// @title  RouteRacerBase\n/// @notice Executes multiple candidate swap routes in isolated, state-reverting\n///         trial subcalls, records each outcome, then executes the route with\n///         the highest output net of its provider fee for real.\n/// @dev    Intended to be called by the RelayApprovalProxy in place of a single\n///         swap provider router. The caller approves this contract for `tokenIn`,\n///         this contract pulls the funds, races the routes, executes the winner\n///         and delivers the output to `recipient`.\n///\n///         Each trial runs in an external self call to `callRoute`. It\n///         reverts with `TrialResult(amountOut)` on swap success, or bubbles\n///         the provider's revert, so no trial leaves state behind. The one\n///         exception is a trial that clears its commit threshold (the last\n///         main when it beats every earlier trial and `minAmountOut`, or a\n///         backup at `minAmountOut`): that frame returns instead and keeps\n///         its execution, which fills the race without a second execution.\n///         Outcomes are recorded and emitted by the parent call, which is\n///         unaffected by the inner reverts.\n///\n///         A provider can charge the caller a fee on routed volume off\n///         chain, which a race on raw output cannot see: a route that\n///         delivers slightly more than a free one would win and cost the\n///         caller net. Each route therefore carries a `feePpm`, and the race\n///         ranks routes by output net of that fee. The fee only picks the\n///         winner: the output delivered to `recipient` is the raw output of\n///         the winner, `minAmountOut` is checked on that raw output, and the\n///         events report raw outputs. With every fee zero the race is a race\n///         on raw output.\n///\n///         Note: a malicious `target` could revert with spoofed `TrialResult`\n///         data to win the race, but a winner that did not keep its trial\n///         execution is re executed for real in a state reverting self call,\n///         its output is measured again and the attempt is rolled back\n///         unless the winner delivers at least its trial claimed output\n///         (which must itself be at least `minAmountOut`). On a rolled back\n///         attempt the race falls back to the next best route, so spoofing\n///         can neither steal funds nor block an otherwise fillable race.\n///\n///         Fee-on-transfer and rebasing tokens are unsupported: output is\n///         measured as this contract's balance delta and delivered via a\n///         plain transfer, so a transfer fee makes the recipient receive\n///         less than the checked minimum.\n///         All of the logic lives here and the reentrancy guard is left\n///         abstract, so `RouteRacer` (transient storage) and\n///         `RouteRacer_NonTstore` (regular storage) are one line each and\n///         cannot drift apart. Pick the one the target chain supports;\n///         `bash-utils/check-cancun-support.sh` reports which.\nabstract contract RouteRacerBase is Ownable, ReentrancyGuard {\n    using SafeTransferLib for address;\n\n    /// @notice Revert if no routes are provided\n    error NoRoutes();\n\n    /// @notice Revert if `mainCount` is zero, which would trial nothing, or\n    ///         exceeds the number of routes supplied\n    error InvalidMainCount(uint256 mainCount, uint256 routeCount);\n\n    /// @notice Revert if every route's trial failed\n    error AllRoutesFailed();\n\n    /// @notice Revert if the best trial output is below the minimum\n    error InsufficientOutput(uint256 amountOut, uint256 minAmountOut);\n\n    /// @notice Revert if the winner's executed output is below its trial-claimed output\n    error WinnerUnderperformed(uint256 amountOut, uint256 trialAmountOut);\n\n    /// @notice Revert if `minAmountOut` is zero, which would disable the theft guard\n    error MinAmountOutRequired();\n\n    /// @notice Revert if a route's `gasLimit` is zero, which would let it\n    ///         starve the other trials and the winner's execution\n    error RouteGasLimitRequired();\n\n    /// @notice Revert if a route targets this contract, which would make the\n    ///         contract its own caller and satisfy the `OnlySelf` gate on\n    ///         `callRoute`\n    error InvalidRouteTarget(address target);\n\n    /// @notice Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.\n    ///         A fee of the whole output leaves nothing to rank and would\n    ///         divide by zero in the commit threshold\n    error InvalidRouteFee(uint256 index, uint256 feePpm);\n\n    /// @notice Recorded as a route's trial failure reason when its `value`\n    ///         exceeds the native value provided by the caller for this fill\n    error ExcessiveRouteValue();\n\n    /// @notice Recorded as a route's trial failure reason when `tokenIn`\n    ///         cannot be approved for the route's spender\n    error RouteApprovalFailed();\n\n    /// @notice Recorded as a route's trial failure reason when the output is\n    ///         native and the route would forward native value. Output is\n    ///         measured as this contract's native balance delta, so any of\n    ///         that value the provider hands back would count as swap output:\n    ///         a refunded fee would go to the recipient instead of `refundTo`,\n    ///         `minAmountOut` would stop being a guarantee, and a route that\n    ///         simply returned what it was given could beat one that swaps\n    error ValueOnNativeOutput();\n\n    /// @notice Revert if msg.value does not cover a native `amountIn`\n    error InvalidMsgValue();\n\n    /// @notice Revert if `tokenIn` and `tokenOut` are the same token, which\n    ///         would break the balance-delta output measurement\n    error IdenticalTokens();\n\n    /// @notice Revert if a recipient is the zero address, either the race's\n    ///         `recipient` or a `withdraw` destination\n    error RecipientCannotBeZeroAddress();\n\n    /// @notice Revert if the recipient is this contract\n    error InvalidRecipient(address recipient);\n\n    /// @notice Revert if the refundTo address is the zero address\n    error RefundToCannotBeZeroAddress();\n\n    /// @notice Revert if `callRoute` is called by anyone other than this contract\n    error OnlySelf();\n\n    /// @notice Used as the success signal of a trial subcall, never a real failure\n    error TrialResult(uint256 amountOut);\n\n    /// @notice Emitted for each route trial that succeeded (when `emitEvents`\n    ///         is set)\n    /// @param index The index of the route in `routes`, where anything at or\n    ///        above the race's `mainCount` is a backup. A backup that the race\n    ///        never reached emits nothing, so use `trialedCount` on\n    ///        `RouteRaceWon` rather than counting these events to know how\n    ///        many candidates were tried. Not indexed: a consumer filters by\n    ///        race transaction, never by route index, and the topic cost more\n    ///        than the data word\n    /// @param target The swap provider router that was called\n    /// @param amountOut The measured output of the trial\n    event RouteTrialSucceeded(uint256 index, address indexed target, uint256 amountOut);\n\n    /// @notice Emitted for each route trial that failed (when `emitEvents` is\n    ///         set)\n    /// @param index The index of the route in `routes`, where anything at or\n    ///        above the race's `mainCount` is a backup\n    /// @param target The swap provider router that was called\n    /// @param revertData The (truncated) revert data of the failed trial\n    event RouteTrialFailed(uint256 index, address indexed target, bytes revertData);\n\n    /// @notice Emitted after the winning route is executed (when `emitEvents` is set)\n    /// @param index The index of the winning route in `routes`, where\n    ///        anything at or above the race's `mainCount` is a backup\n    /// @param target The swap provider router of the winning route\n    /// @param amountOut The actual executed output delivered to the recipient\n    /// @param trialedCount How many candidates were actually trialed, always a\n    ///        prefix of `routes`. Equals `mainCount` when the mains filled the\n    ///        race and the backups were never reached, so a consumer can tell\n    ///        a skipped candidate from a failed one instead of undercounting\n    ///        from the trial events\n    /// @param mainCount How many of `routes` were mains: `routes.length` on\n    ///        `race`, the caller's `mainCount` on `raceWithBackups`. With it\n    ///        the event alone tells a rescue (`index >= mainCount`) from a\n    ///        main's win and whether the backups ran at all (`trialedCount >\n    ///        mainCount`), without reading the race calldata\n    /// @param metadata Additional data to associate the race to\n    event RouteRaceWon(\n        uint256 indexed index,\n        address indexed target,\n        uint256 amountOut,\n        uint256 trialedCount,\n        uint256 mainCount,\n        bytes metadata\n    );\n\n    /// @notice Emitted when a selected route's real execution fails or\n    ///         under-delivers and is rolled back, before the race falls back\n    ///         to the next-best route (when `emitEvents` is set)\n    /// @param index The index of the failed route in `routes`, where anything\n    ///        at or above the race's `mainCount` is a backup\n    /// @param target The swap provider router that was called\n    /// @param revertData The (truncated) revert data of the failed execution\n    event RouteExecutionFailed(uint256 indexed index, address indexed target, bytes revertData);\n\n    /// @notice Max bytes of trial revert data copied back and emitted\n    uint256 private constant MAX_REVERT_DATA_BYTES = 512;\n\n    /// @notice Sentinel index meaning \"no successful route yet\"\n    uint256 private constant NO_WINNER = type(uint256).max;\n\n    /// @notice The unit of `Route.feePpm`: a fee of this many parts is the\n    ///         whole output. Parts per million, so a basis point is 100 and\n    ///         a deal quoted in fractions of a basis point still fits\n    uint256 public constant FEE_DENOMINATOR = 1_000_000;\n\n    /// @notice Gas given to the `allowance` read after a kept execution. A\n    ///         cold read through a proxy needs under 10,000; see\n    ///         `_allowanceIsZero` for why the frame's gas is not forwarded\n    uint256 private constant ALLOWANCE_READ_GAS = 30_000;\n\n    receive() external payable {}\n\n    constructor(address _owner) {\n        _initializeOwner(_owner);\n    }\n\n    /// @notice Withdraw funds that got stuck in the contract\n    /// @dev    Sweeps the whole balance. `onlyOwner`, so naming a recipient\n    ///         grants nothing the owner could not already do by withdrawing to\n    ///         themselves and transferring on; it only saves that second step\n    /// @param token The token to sweep, or address(0) for the native balance\n    /// @param to The address to send it to\n    function withdraw(address token, address to) external onlyOwner {\n        if (to == address(0)) {\n            revert RecipientCannotBeZeroAddress();\n        }\n\n        if (token == address(0)) {\n            to.safeTransferETH(address(this).balance);\n        } else {\n            token.safeTransfer(to, token.balanceOf(address(this)));\n        }\n    }\n\n    /// @notice Everything a race carries between its steps, in memory so the\n    ///         steps can be separate functions without a dozen stack values each\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native)\n    /// @param minAmountOut The caller's floor, and the backup trigger\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param preBalance The native balance this contract held before the\n    ///        call, which is never refunded or forwarded to a route\n    /// @param preTokenInBalance The `tokenIn` balance this contract held\n    ///        before the pull, which is never refunded either\n    /// @param outBalanceBefore This contract's `tokenOut` balance before any\n    ///        route ran, measured once because every frame that runs before\n    ///        the fill reverts\n    /// @param maxRouteValue The most native value any single route may forward\n    /// @param outputs Each trialed route's measured output, zero when it\n    ///        failed, was discarded, or was never reached\n    /// @param trialGas Gas each trialed route's trial consumed, measured in\n    ///        the parent frame around the trial call, zero when it failed or\n    ///        was never reached. Only read to break ties\n    /// @param bestOutput The raw trial output of the current leader, the\n    ///        route that would be executed if the trials stopped now. The\n    ///        leader is the eligible route (at or above `minAmountOut`) with\n    ///        the highest net output, or while none is eligible the route\n    ///        with the highest raw output, reported by `InsufficientOutput`\n    /// @param bestNet `bestOutput` net of the leader's fee, see `_netOf`\n    /// @param bestGas The trial gas of the leader\n    /// @param winnerIndex The leader, or `NO_WINNER`\n    /// @param amountOut Nonzero once a route has been executed for real: a\n    ///        trial that kept its execution, or a winner executed by\n    ///        `_executeBest`\n    /// @param trialedCount How many routes were trialed, always a prefix of\n    ///        the list\n    /// @param mainCount How many routes are mains, reported on the win event\n    /// @param emitEvents Whether to emit the per trial and winner events\n    struct RaceState {\n        // The race's arguments\n        address tokenIn;\n        uint256 amountIn;\n        address tokenOut;\n        uint256 minAmountOut;\n        address recipient;\n        address refundTo;\n        // Fixed before any route runs\n        uint256 preBalance;\n        uint256 preTokenInBalance;\n        uint256 outBalanceBefore;\n        uint256 maxRouteValue;\n        // What the trials found\n        uint256[] outputs;\n        uint256[] trialGas;\n        uint256 bestOutput;\n        uint256 bestNet;\n        uint256 bestGas;\n        uint256 winnerIndex;\n        uint256 amountOut;\n        uint256 trialedCount;\n        // Reporting\n        uint256 mainCount;\n        bool emitEvents;\n    }\n\n    /// @notice Pull `amountIn` of `tokenIn` from the caller, trial every route,\n    ///         execute the one with the highest output net of its fee and\n    ///         deliver its raw output of `tokenOut` to `recipient`\n    /// @dev    The caller must have approved this contract for `amountIn` of\n    ///         `tokenIn` (or send it as msg.value when `tokenIn` is native).\n    ///         Swap calldata must be built with this contract as taker/recipient\n    ///         so outputs land here and can be measured. Among the routes\n    ///         whose raw output clears `minAmountOut` the one with the\n    ///         highest output net of its `feePpm` wins; a route below the\n    ///         floor never wins over one that clears it, whatever its net.\n    ///         The last candidate keeps its own execution when its raw\n    ///         output already matches every earlier trial net of fees and\n    ///         clears the floor, which fills the race without a second\n    ///         execution, so order candidates worst to best by expected net\n    ///         output to hit that path. Among the other candidates an exact\n    ///         tie on net output goes to the route whose trial used less\n    ///         gas, not to the earlier one. Otherwise candidates are\n    ///         executed in descending net output order: an execution that\n    ///         fails or delivers less than its trial output is rolled back\n    ///         and the next-best route is tried instead. Reverts if every\n    ///         route fails, no trial output clears `minAmountOut`, or every\n    ///         candidate's execution fails. Leftover native and unspent\n    ///         input tokens are refunded to `refundTo`.\n    ///\n    ///         Every route here is a main: all of them are trialed. To hold\n    ///         some routes back as backups, call `raceWithBackups`.\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native, must differ from `tokenIn`)\n    /// @param minAmountOut The minimum acceptable executed output (must be > 0)\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param routes The candidate swap routes to race. Must not be empty\n    /// @param emitEvents Whether to emit per-trial and winner events\n    /// @param metadata Additional data to associate the race to\n    /// @return winnerIndex The index of the executed route\n    /// @return amountOut The actual output delivered to the recipient\n    function race(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        bool emitEvents,\n        bytes calldata metadata\n    ) external payable nonReentrant returns (uint256 winnerIndex, uint256 amountOut) {\n        return _race(\n            tokenIn, amountIn, tokenOut, minAmountOut, recipient, refundTo, routes, routes.length, emitEvents, metadata\n        );\n    }\n\n    /// @notice `race`, with the tail of `routes` held back as backups that are\n    ///         trialed only when the mains cannot fill the order\n    /// @dev    Identical to `race` except that only the first `mainCount`\n    ///         routes are trialed up front. The rest are reached only when\n    ///         the mains leave the race unfillable, meaning none of them\n    ///         succeeded, the best of them is below `minAmountOut`, or every\n    ///         main that cleared it failed its real execution, so a race\n    ///         whose mains fill never pays to trial a backup. A backup\n    ///         is a guard against a main failing, not against a main being\n    ///         mispriced: a main that clears the floor wins even where a\n    ///         backup would have paid more. Backups are not raced against\n    ///         each other either: they are trialed in order and the first\n    ///         that clears `minAmountOut` is executed, as its trial, so order\n    ///         them most reliable first. Both lists share one index space,\n    ///         mains first, so any index at or above `mainCount` is a backup.\n    /// @param tokenIn The input token (address(0) for native)\n    /// @param amountIn The input amount\n    /// @param tokenOut The output token (address(0) for native, must differ from `tokenIn`)\n    /// @param minAmountOut The minimum acceptable executed output (must be > 0).\n    ///        This is doing double duty: it is both the caller's protection\n    ///        floor and the trigger for the backup routes, which are only\n    ///        trialed when the mains cannot clear it. Raising it therefore\n    ///        makes backups fire more often and also makes more fills revert,\n    ///        so choose it with both effects in mind\n    /// @param recipient The address to receive the winning output\n    /// @param refundTo The address to refund any leftover funds to\n    /// @param routes Every candidate, mains first then the backups. Must not\n    ///        be empty\n    /// @param mainCount How many of `routes` are mains. Must be nonzero and no\n    ///        greater than `routes.length`; equal to it means no backups,\n    ///        which is exactly `race`. The rest are tried in order until one\n    ///        clears the floor\n    /// @param emitEvents Whether to emit per-trial and winner events\n    /// @param metadata Additional data to associate the race to\n    /// @return winnerIndex The index of the executed route in `routes`, where\n    ///         anything at or above `mainCount` is a backup\n    /// @return amountOut The actual output delivered to the recipient\n    function raceWithBackups(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        uint256 mainCount,\n        bool emitEvents,\n        bytes calldata metadata\n    ) external payable nonReentrant returns (uint256 winnerIndex, uint256 amountOut) {\n        return _race(\n            tokenIn, amountIn, tokenOut, minAmountOut, recipient, refundTo, routes, mainCount, emitEvents, metadata\n        );\n    }\n\n    /// @notice The race itself, shared by both entrypoints: validate, pull the\n    ///         input, trial the mains, execute the best (trialing the backups\n    ///         if need be), deliver and refund\n    /// @dev    `race` passes `routes.length` as `mainCount`, so every route\n    ///         is a main there\n    function _race(\n        address tokenIn,\n        uint256 amountIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        Route[] calldata routes,\n        uint256 mainCount,\n        bool emitEvents,\n        bytes calldata metadata\n    ) internal returns (uint256, uint256) {\n        _validate(tokenIn, tokenOut, minAmountOut, recipient, refundTo, routes.length, mainCount);\n\n        // The parameters are dead after this block; the steps read `s`\n        RaceState memory s;\n        s.tokenIn = tokenIn;\n        s.amountIn = amountIn;\n        s.tokenOut = tokenOut;\n        s.minAmountOut = minAmountOut;\n        s.recipient = recipient;\n        s.refundTo = refundTo;\n        s.emitEvents = emitEvents;\n        s.mainCount = mainCount;\n        s.outputs = new uint256[](routes.length);\n        s.trialGas = new uint256[](routes.length);\n        s.winnerIndex = NO_WINNER;\n\n        _pullInput(s);\n        _trialRoutes(routes, 0, mainCount, false, s);\n        _executeBest(routes, s);\n        _settle(routes, s, metadata);\n\n        return (s.winnerIndex, s.amountOut);\n    }\n\n    /// @notice Whether the trials so far can fill the race: a route kept its\n    ///         own execution, or the best trial clears the minimum\n    function _fillable(RaceState memory s) internal pure returns (bool) {\n        return s.amountOut != 0 || (s.winnerIndex != NO_WINNER && s.bestOutput >= s.minAmountOut);\n    }\n\n    /// @notice Reject the arguments a race can never run with\n    function _validate(\n        address tokenIn,\n        address tokenOut,\n        uint256 minAmountOut,\n        address recipient,\n        address refundTo,\n        uint256 routeCount,\n        uint256 mainCount\n    ) internal view {\n        if (routeCount == 0) {\n            revert NoRoutes();\n        }\n\n        // Zero would trial nothing, mains or backups; past the end would run\n        // off the array mid loop after earlier routes had already burned\n        // real trials\n        if (mainCount == 0 || mainCount > routeCount) {\n            revert InvalidMainCount(mainCount, routeCount);\n        }\n\n        if (recipient == address(0)) {\n            revert RecipientCannotBeZeroAddress();\n        }\n\n        // For safety, revert if the recipient is this contract, mirroring\n        // the RelayRouter behavior\n        if (recipient == address(this)) {\n            revert InvalidRecipient(address(this));\n        }\n\n        if (refundTo == address(0)) {\n            revert RefundToCannotBeZeroAddress();\n        }\n\n        if (minAmountOut == 0) {\n            revert MinAmountOutRequired();\n        }\n\n        // The output is measured as a balance delta, which is broken when\n        // the input and output tokens are the same\n        if (tokenIn == tokenOut) {\n            revert IdenticalTokens();\n        }\n    }\n\n    /// @notice Pull the input funds from the caller and take the balance\n    ///         snapshots the rest of the race measures against\n    function _pullInput(RaceState memory s) internal {\n        // Snapshot any pre-existing native balance so it is never refunded\n        // to the caller or forwarded to a route\n        s.preBalance = address(this).balance - msg.value;\n\n        // Pull the input funds from the caller, snapshotting any pre-existing\n        // input token balance so it is never refunded. A route can only\n        // forward native value provided by the caller for this fill, never\n        // the contract's own residual balance\n        if (s.tokenIn == address(0)) {\n            if (msg.value < s.amountIn) {\n                revert InvalidMsgValue();\n            }\n            s.maxRouteValue = s.amountIn;\n        } else {\n            s.preTokenInBalance = s.tokenIn.balanceOf(address(this));\n            s.tokenIn.safeTransferFrom(msg.sender, address(this), s.amountIn);\n            s.maxRouteValue = msg.value;\n        }\n\n        // Measured once: every trial and every failed execution reverts, so\n        // the output balance is the same before each of them (GAS.md step 7)\n        s.outBalanceBefore = s.tokenOut == address(0) ? address(this).balance : s.tokenOut.balanceOf(address(this));\n    }\n\n    /// @notice Trial `routes[from..to)` in isolated, state-reverting subcalls,\n    ///         recording each output and tracking the leader\n    /// @dev    A trial is run with a commit threshold when its result can end\n    ///         the race: if it measures at least `minAmountOut` and, net of\n    ///         its fee, at least as much as every earlier trial, it keeps\n    ///         its execution instead of rolling it back, which fills the\n    ///         race without a second execution.\n    ///\n    ///         Mains (`rescue` false) race: every one is trialed and\n    ///         only the last gets the threshold, so the best net output wins\n    ///         and the caller orders the likely winner last. Backups\n    ///         (`rescue` true) rescue: each is trialed with the\n    ///         threshold, the first that clears the floor keeps its execution\n    ///         and the rest are never trialed. Backups only run when the\n    ///         mains left the race unfillable, so competing them on price\n    ///         would spend a trial per backup for a fill that only needs one\n    ///         route that works; the caller orders the most reliable first\n    function _trialRoutes(Route[] calldata routes, uint256 from, uint256 to, bool rescue, RaceState memory s) internal {\n        // The loop invariants, read once instead of once per route\n        address tokenOut = s.tokenOut;\n        uint256 minAmountOut = s.minAmountOut;\n        uint256 maxRouteValue = s.maxRouteValue;\n        bool emitEvents = s.emitEvents;\n\n        for (uint256 i = from; i < to;) {\n            Route calldata route = routes[i];\n\n            // Every route must carry its own gas limit so a single route can\n            // never starve the other trials or the winner's execution\n            if (route.gasLimit == 0) {\n                revert RouteGasLimitRequired();\n            }\n\n            // A route that targets this contract would be its own caller, pass\n            // the `OnlySelf` gate on `callRoute` and re enter it with a forged\n            // payload, including a `tokenIn` this race never touched. Mirrors\n            // the `recipient == address(this)` rejection\n            if (route.target == address(this)) {\n                revert InvalidRouteTarget(route.target);\n            }\n\n            // Read once: the net output and the commit threshold both use it\n            uint256 feePpm = route.feePpm;\n            if (feePpm >= FEE_DENOMINATOR) {\n                revert InvalidRouteFee(i, feePpm);\n            }\n\n            bool committed;\n            bool success;\n            uint256 output;\n            uint256 trialGas;\n            bytes memory revertData;\n\n            if (route.value > maxRouteValue) {\n                // Record an over-value route as a failed trial without\n                // executing it, so it can neither win nor spend the\n                // contract's residual native balance\n                revertData = abi.encodeWithSelector(ExcessiveRouteValue.selector);\n            } else if (tokenOut == address(0) && route.value != 0) {\n                // A native output cannot be told apart from returned value,\n                // so a route that forwards value into a native output race\n                // fails its trial rather than being measured wrongly. This\n                // keeps `minAmountOut` a real floor on native output\n                revertData = abi.encodeWithSelector(ValueOnNativeOutput.selector);\n            } else {\n                // Measured around the whole trial, approval and clear\n                // included, since the winner's real execution repeats all of\n                // it. Only used to break an exact tie on output\n                uint256 gasBefore = gasleft();\n\n                // Zero always rolls back. The last main keeps its execution\n                // when it clears the floor and, net of its fee, matches the\n                // leader: the frame compares raw output against one word,\n                // so the leader's net is scaled back to the raw output this\n                // route needs for it. An ineligible leader sets no bar\n                // beyond the floor, since an eligible route beats it\n                // whatever its net. A backup commits at the floor and\n                // nothing higher: it only runs when no trialed route clears\n                // the floor, and a spoofed trial claiming more must not\n                // raise the bar for the honest backups after it, or the\n                // fill would go through the fallback and execute twice\n                uint256 commitThreshold;\n                if (rescue) {\n                    commitThreshold = minAmountOut;\n                } else if (i + 1 == to) {\n                    commitThreshold = minAmountOut;\n                    if (s.bestOutput >= minAmountOut) {\n                        uint256 rawToMatch = _rawFor(s.bestNet, feePpm);\n                        if (rawToMatch > commitThreshold) {\n                            commitThreshold = rawToMatch;\n                        }\n                    }\n                }\n\n                (committed, success, output, revertData) = _approveAndTrial(route, s, commitThreshold);\n\n                unchecked {\n                    // gas only goes down, so this cannot underflow\n                    trialGas = gasBefore - gasleft();\n                }\n            }\n\n            if (emitEvents) {\n                if (success) {\n                    emit RouteTrialSucceeded(i, route.target, output);\n                } else {\n                    emit RouteTrialFailed(i, route.target, revertData);\n                }\n            }\n\n            if (success) {\n                s.outputs[i] = output;\n                s.trialGas[i] = trialGas;\n\n                // A route that kept its execution wins outright even on an\n                // exact tie: keeping it costs nothing more, while any other\n                // winner would have to be executed a second time\n                uint256 net = _netOf(output, feePpm);\n                if (committed || _leads(output, net, trialGas, s)) {\n                    s.bestOutput = output;\n                    s.bestNet = net;\n                    s.bestGas = trialGas;\n                    s.winnerIndex = i;\n                }\n\n                // A kept execution fills the race and ends the search: a\n                // nonzero `amountOut` (always at least `minAmountOut`, which\n                // cannot be zero) is what tells the rest of the race so. A\n                // main only commits as the last of its range, a backup can\n                // commit anywhere in it, and `trialedCount` says where the\n                // search stopped either way\n                if (committed) {\n                    s.amountOut = output;\n                    unchecked {\n                        s.trialedCount = i + 1;\n                    }\n                    return;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n\n        s.trialedCount = to;\n    }\n\n    /// @notice Execute the trialed candidates in descending net output order\n    ///         until one delivers, trialing the backups whenever the trialed\n    ///         routes cannot fill the race\n    /// @dev    State did not change since the trials (they all reverted), but\n    ///         a route can still behave differently when re-executed (e.g. by\n    ///         observing the lower remaining gas or by having spoofed its\n    ///         trial), so each execution runs in its own state-reverting\n    ///         self-call: a failing or under-delivering attempt is rolled back\n    ///         and the next-best route is tried instead of losing the entire\n    ///         fill. Whenever nothing trialed is left that clears the floor,\n    ///         any backups not yet trialed are trialed and the search\n    ///         continues over them; when none are left the whole fill\n    ///         reverts. Only the re-measured output is ever delivered. Skipped\n    ///         entirely when the last trialed route already kept its execution\n    function _executeBest(Route[] calldata routes, RaceState memory s) internal {\n        while (s.amountOut == 0) {\n            if (!_fillable(s)) {\n                // Nothing trialed clears the floor: trial the backups now, on\n                // the same state the mains saw, since every failed execution\n                // rolled back. A backup that commits ends the loop; otherwise\n                // the best of them is executed next\n                if (s.trialedCount < routes.length) {\n                    _trialRoutes(routes, s.trialedCount, routes.length, true, s);\n                    continue;\n                }\n\n                // Revert the entire fill: no route succeeded, or even the\n                // best trial output cannot satisfy the minimum\n                if (s.winnerIndex == NO_WINNER) {\n                    revert AllRoutesFailed();\n                }\n                revert InsufficientOutput(s.bestOutput, s.minAmountOut);\n            }\n\n            // Forward all remaining gas; the route's own limit applies inside\n            // the frame, around the swap\n            (bool committed, uint256 executedAmountOut) =\n                _callRoute(routes[s.winnerIndex], false, s.bestOutput, s, gasleft());\n            if (committed) {\n                s.amountOut = executedAmountOut;\n                break;\n            }\n\n            if (s.emitEvents) {\n                emit RouteExecutionFailed(s.winnerIndex, routes[s.winnerIndex].target, _boundedRevertData());\n            }\n\n            // Discard the failed candidate and select the next best\n            s.outputs[s.winnerIndex] = 0;\n            _selectBest(routes, s);\n        }\n    }\n\n    /// @notice Point `winnerIndex`, `bestOutput` and `bestNet` at the best\n    ///         remaining trialed route, or at `NO_WINNER` and zero when none\n    ///         is left. Ranked by `_leads`, as the trial loop does. Net\n    ///         outputs are recomputed from the raw outputs and the routes'\n    ///         fees rather than kept per route: this only runs after a\n    ///         failed execution, so the hot path stores nothing\n    function _selectBest(Route[] calldata routes, RaceState memory s) internal pure {\n        uint256[] memory outputs = s.outputs;\n        uint256[] memory trialGas = s.trialGas;\n        uint256 count = outputs.length;\n        s.bestOutput = 0;\n        s.bestNet = 0;\n        s.bestGas = 0;\n        s.winnerIndex = NO_WINNER;\n        for (uint256 i = 0; i < count;) {\n            uint256 candidate = outputs[i];\n            if (candidate != 0) {\n                uint256 net = _netOf(candidate, routes[i].feePpm);\n                if (_leads(candidate, net, trialGas[i], s)) {\n                    s.bestOutput = candidate;\n                    s.bestNet = net;\n                    s.bestGas = trialGas[i];\n                    s.winnerIndex = i;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    /// @notice Whether a successful trial with raw `output`, `net` of its\n    ///         fee and costing `trialGas` takes the lead from the leader in\n    ///         `s`\n    /// @dev    Higher net output wins, among the routes that clear the floor\n    ///         first: a route below it can never be executed, so it must not\n    ///         hide one that can, however good its net. An exact tie goes to\n    ///         the route whose trial cost less gas, because the winner's\n    ///         real execution pays that gas again, not to the earlier one\n    function _leads(uint256 output, uint256 net, uint256 trialGas, RaceState memory s) private pure returns (bool) {\n        if (s.winnerIndex == NO_WINNER) {\n            return true;\n        }\n        bool eligible = output >= s.minAmountOut;\n        bool leaderEligible = s.bestOutput >= s.minAmountOut;\n        if (eligible != leaderEligible) {\n            return eligible;\n        }\n        if (!eligible) {\n            // Neither clears the floor, so neither can be executed and the\n            // net has no job: keep the highest raw output, which is what\n            // `InsufficientOutput` reports, as it did before fees\n            return output > s.bestOutput || (output == s.bestOutput && trialGas < s.bestGas);\n        }\n        return net > s.bestNet || (net == s.bestNet && trialGas < s.bestGas);\n    }\n\n    /// @notice `output` net of a `feePpm` fee, rounded down\n    /// @dev    Split at the denominator so the product never overflows: a\n    ///         trial output is whatever the route's frame reports, and a\n    ///         spoofed claim must cost that route the race, not the whole\n    ///         fill. The whole part times the kept share is at most the\n    ///         output and the remainder's share is below the denominator,\n    ///         so nothing here can overflow. Zero fee is the common case\n    ///         and skips the arithmetic\n    function _netOf(uint256 output, uint256 feePpm) private pure returns (uint256) {\n        if (feePpm == 0) {\n            return output;\n        }\n        unchecked {\n            uint256 keptPpm = FEE_DENOMINATOR - feePpm;\n            return (output / FEE_DENOMINATOR) * keptPpm + (output % FEE_DENOMINATOR) * keptPpm / FEE_DENOMINATOR;\n        }\n    }\n\n    /// @notice The smallest raw output whose net at `feePpm` is at least\n    ///         `net`: the inverse of `_netOf`, rounded up\n    /// @dev    `_netOf(raw, feePpm) >= net` holds exactly when `raw` is at\n    ///         least this, so the last main's commit threshold matches the\n    ///         comparison the trial loop would have made. A leader net above\n    ///         `max / FEE_DENOMINATOR` is a spoofed trial: no real token has\n    ///         an output that large, so the bar saturates to `max` instead\n    ///         of computing the exact inverse (which would still fit for\n    ///         some of those nets); such a last main rolls back and wins\n    ///         through the fallback instead, same amount delivered. `feePpm` is below\n    ///         `FEE_DENOMINATOR`, checked by the trial loop, so the divisor\n    ///         is nonzero, and the rounding step cannot overflow: a divisor\n    ///         of one leaves no remainder, a larger one leaves room\n    function _rawFor(uint256 net, uint256 feePpm) private pure returns (uint256) {\n        if (feePpm == 0) {\n            return net;\n        }\n        if (net > type(uint256).max / FEE_DENOMINATOR) {\n            return type(uint256).max;\n        }\n        unchecked {\n            uint256 keptPpm = FEE_DENOMINATOR - feePpm;\n            uint256 scaled = net * FEE_DENOMINATOR;\n            return scaled / keptPpm + (scaled % keptPpm == 0 ? 0 : 1);\n        }\n    }\n\n    /// @notice Deliver the output to the recipient, report the win with the\n    ///         race `metadata`, and refund any leftover native and unspent\n    ///         input tokens from this call to `refundTo`, excluding any\n    ///         pre-existing contract balance\n    function _settle(Route[] calldata routes, RaceState memory s, bytes calldata metadata) internal {\n        if (s.tokenOut == address(0)) {\n            s.recipient.safeTransferETH(s.amountOut);\n        } else {\n            s.tokenOut.safeTransfer(s.recipient, s.amountOut);\n        }\n\n        if (s.emitEvents) {\n            emit RouteRaceWon(\n                s.winnerIndex, routes[s.winnerIndex].target, s.amountOut, s.trialedCount, s.mainCount, metadata\n            );\n        }\n\n        uint256 leftover = address(this).balance - s.preBalance;\n        if (leftover > 0) {\n            s.refundTo.safeTransferETH(leftover);\n        }\n\n        if (s.tokenIn != address(0)) {\n            uint256 leftoverIn = s.tokenIn.balanceOf(address(this)) - s.preTokenInBalance;\n            if (leftoverIn > 0) {\n                s.tokenIn.safeTransfer(s.refundTo, leftoverIn);\n            }\n        }\n    }\n\n    /// @notice Run one route in its own call frame and measure its output.\n    ///         A trial reverts with `TrialResult(output)` so that everything\n    ///         the route did is discarded, unless the output clears the commit\n    ///         threshold, in which case the frame returns the output and keeps\n    ///         the execution. The winner's execution returns its output when\n    ///         that is at least the trial's claim and reverts with\n    ///         `WinnerUnderperformed` otherwise, so the race can roll it back\n    /// @dev    Only callable by this contract itself (via `_callRoute`), which\n    ///         is load bearing: the balance snapshot is an input, so a forged\n    ///         snapshot of zero would report the contract's whole `tokenOut`\n    ///         balance as one route's output. Takes no ABI arguments:\n    ///         `_callRoute` writes a fixed layout payload after the selector\n    ///         and this reads it back at the same offsets (GAS.md step 18).\n    ///         Layout, offsets from the start of calldata:\n    ///\n    ///           0x004  isTrial\n    ///           0x024  threshold (commit threshold for a trial, the trial\n    ///                  claimed output for the winner)\n    ///           0x044  tokenIn\n    ///           0x064  amountIn\n    ///           0x084  tokenOut\n    ///           0x0a4  outBalanceBefore\n    ///           0x0c4  target, spender, value, gasLimit (the route head)\n    ///           0x144  callData length\n    ///           0x164  callData bytes\n    function callRoute() external returns (uint256 output) {\n        if (msg.sender != address(this)) {\n            revert OnlySelf();\n        }\n\n        bool isTrial;\n        uint256 threshold;\n        address tokenIn;\n        uint256 amountIn;\n        address tokenOut;\n        uint256 outBalanceBefore;\n        address target;\n        address spender;\n        uint256 value;\n        uint256 gasLimit;\n        assembly (\"memory-safe\") {\n            isTrial := calldataload(0x04)\n            threshold := calldataload(0x24)\n            tokenIn := calldataload(0x44)\n            amountIn := calldataload(0x64)\n            tokenOut := calldataload(0x84)\n            outBalanceBefore := calldataload(0xa4)\n            // The route head was copied raw. `target` only ever feeds the\n            // `call` address operand, which the EVM truncates, but `spender`\n            // is compared with zero and handed to `approve` and `allowance`\n            // as a whole word, so it is masked here even though\n            // `_approveAndTrial` already rejected a dirty word before this\n            // frame could run\n            target := calldataload(0xc4)\n            spender := and(calldataload(0xe4), 0xffffffffffffffffffffffffffffffffffffffff)\n            value := calldataload(0x104)\n            gasLimit := calldataload(0x124)\n        }\n\n        // `race` measured this already and nothing changed since, because\n        // every trial and every failed execution reverts. Only the native\n        // value this call is about to spend has to be discounted\n        if (tokenOut == address(0)) {\n            outBalanceBefore -= value;\n        }\n\n        // Winner path only: a trial's approval is set and cleared by `race`\n        // in its own frame, where the write survives the trial's revert\n        bool approvalNeeded = !isTrial && tokenIn != address(0) && spender != address(0);\n        if (approvalNeeded) {\n            tokenIn.safeApproveWithRetry(spender, amountIn);\n        }\n\n        // Execute the swap, bounded by the route's gas limit, bubbling up\n        // the provider's revert (truncated to MAX_REVERT_DATA_BYTES, so a\n        // returndata bomb cannot eat the parent's gas) on failure\n        assembly (\"memory-safe\") {\n            // The swap calldata goes to the temporary region past the free\n            // memory pointer: nothing else needs it after the call, and the\n            // revert data below reuses the same region\n            let ptr := mload(0x40)\n            let cdLen := calldataload(0x144)\n            calldatacopy(ptr, 0x164, cdLen)\n            if iszero(call(gasLimit, target, value, ptr, cdLen, 0, 0)) {\n                let retSize := returndatasize()\n                if gt(retSize, MAX_REVERT_DATA_BYTES) {\n                    retSize := MAX_REVERT_DATA_BYTES\n                }\n                returndatacopy(ptr, 0, retSize)\n                revert(ptr, retSize)\n            }\n        }\n\n        // Clear any leftover approval, unless the swap already spent it all\n        if (approvalNeeded && !_allowanceIsZero(tokenIn, spender)) {\n            tokenIn.safeApproveWithRetry(spender, 0);\n        }\n\n        uint256 balanceAfter = tokenOut == address(0) ? address(this).balance : tokenOut.balanceOf(address(this));\n        output = balanceAfter - outBalanceBefore;\n\n        if (isTrial) {\n            // Keeping the execution is only ever an improvement on\n            // re-executing this same route: the output is measured here, in\n            // the frame that produced it, so there is nothing left to verify\n            if (threshold != 0 && output >= threshold) {\n                return output;\n            }\n            revert TrialResult(output);\n        }\n\n        // The route must deliver at least its trial-claimed output, so a\n        // route that spoofs or under-delivers is rolled back instead of\n        // extracting the surplus between its claim and the race's\n        // `minAmountOut`\n        if (output < threshold) {\n            revert WinnerUnderperformed(output, threshold);\n        }\n    }\n\n    /// @notice Build the fixed layout `callRoute` payload for `route` in the\n    ///         temporary region past the free memory pointer and self call\n    ///         with it. `route.callData` is bound through Solidity so the\n    ///         decoder's bounds checks still run\n    /// @return committed Whether the frame returned, meaning it kept its\n    ///         execution. The callee is this contract's `callRoute`, which\n    ///         returns exactly one word or reverts, so a returned frame always\n    ///         has 32 bytes of return data; the copy below relies on that and\n    ///         would halt the race if a future path returned nothing\n    /// @return output The returned output when `committed`, otherwise zero.\n    ///         The frame's return data is left in place for the caller to read\n    function _callRoute(Route calldata route, bool isTrial, uint256 threshold, RaceState memory s, uint256 gasToForward)\n        private\n        returns (bool committed, uint256 output)\n    {\n        address tokenIn = s.tokenIn;\n        uint256 amountIn = s.amountIn;\n        address tokenOut = s.tokenOut;\n        uint256 outBalanceBefore = s.outBalanceBefore;\n        bytes calldata cd = route.callData;\n        bytes4 sel = RouteRacerBase.callRoute.selector;\n        assembly (\"memory-safe\") {\n            let buf := mload(0x40)\n            // The selector first: the next word overwrites its low 28 bytes\n            mstore(buf, sel)\n            mstore(add(buf, 0x04), isTrial)\n            mstore(add(buf, 0x24), threshold)\n            mstore(add(buf, 0x44), tokenIn)\n            mstore(add(buf, 0x64), amountIn)\n            mstore(add(buf, 0x84), tokenOut)\n            mstore(add(buf, 0xa4), outBalanceBefore)\n            // The route head, raw: target, spender, value, gasLimit. The\n            // fee word that follows stays behind, the frame never reads it\n            calldatacopy(add(buf, 0xc4), route, 0x80)\n            mstore(add(buf, 0x144), cd.length)\n            calldatacopy(add(buf, 0x164), cd.offset, cd.length)\n            // `callRoute` returns its one output word when the frame kept\n            // its execution and reverts otherwise, so the call status alone\n            // says which\n            committed := call(gasToForward, address(), 0, buf, add(0x164, cd.length), 0, 0)\n            if committed {\n                returndatacopy(0x00, 0, 0x20)\n                output := mload(0x00)\n            }\n        }\n    }\n\n    /// @notice Approve the route's spender, trial the route, then clear the\n    ///         approval, keeping both allowance writes in this frame instead\n    ///         of the trial's\n    /// @dev    A rolled back trial reverts, so an approval written inside its\n    ///         frame would be discarded without a refund and its clear would\n    ///         never run. Writing the approve and the clear here, in the\n    ///         parent frame, makes the pair cheap (GAS.md step 3). Only one\n    ///         spender is approved at any moment, the same exposure as\n    ///         approving inside the trial.\n    /// @param route The route to trial\n    /// @param s The race, read for its input token and amount, its output\n    ///        token and its `tokenOut` balance snapshot\n    /// @param commitThreshold The output at or above which the trial keeps its\n    ///        execution instead of rolling it back; zero always rolls back\n    /// @return committed Whether the trial kept its execution, meaning the\n    ///         race is already filled by this route\n    /// @return success Whether the trial swap succeeded\n    /// @return output The measured output of the trial (0 on failure)\n    /// @return revertData The (truncated) revert data on failure, empty on success\n    function _approveAndTrial(Route calldata route, RaceState memory s, uint256 commitThreshold)\n        internal\n        returns (bool committed, bool success, uint256 output, bytes memory revertData)\n    {\n        address tokenIn = s.tokenIn;\n\n        // A zero spender means the route needs no approval, and a native\n        // input has no allowance to set. Read through Solidity even for a\n        // native input, so the calldata validator rejects dirty upper bits:\n        // `callRoute` copies the route head raw, so this is the only check\n        address spender = route.spender;\n        if (tokenIn == address(0)) {\n            spender = address(0);\n        }\n\n        if (spender != address(0) && !_tryApprove(tokenIn, spender, s.amountIn)) {\n            // A failed attempt can still have written an allowance while\n            // reporting failure, and unlike an approval made inside a trial\n            // frame there is no revert to undo it, so clear it before\n            // bailing out. Best effort by design: a token this broken must\n            // not be able to revert an otherwise fillable race\n            _approve(tokenIn, spender, 0);\n\n            // A route whose input cannot be approved fails its own trial\n            // rather than reverting the whole race\n            return (false, false, 0, abi.encodeWithSelector(RouteApprovalFailed.selector));\n        }\n\n        // Trial the route in a self call bounded by its gas limit so a bad\n        // route cannot eat the entire transaction's gas. The frame returns\n        // only when it kept its execution: the route is then the winner,\n        // already executed for real and already measured\n        (committed, output) = _callRoute(route, true, commitThreshold, s, route.gasLimit);\n        success = committed;\n\n        if (!committed) {\n            // A rolled back trial that succeeded reverts with exactly\n            // `TrialResult(uint256)`; anything else is the provider's own\n            // revert, copied (bounded) for reporting\n            bytes4 trialResult = TrialResult.selector;\n            assembly (\"memory-safe\") {\n                if eq(returndatasize(), 36) {\n                    returndatacopy(0x00, 0, 36)\n                    success := eq(shr(224, mload(0x00)), shr(224, trialResult))\n                    output := mul(success, mload(0x04))\n                }\n            }\n            if (!success) {\n                revertData = _boundedRevertData();\n            }\n        }\n\n        if (spender != address(0)) {\n            // Revoking is required to succeed: an allowance that cannot be\n            // cleared would outlive the race. A kept execution has usually\n            // spent the whole allowance already, and a slot that reads zero\n            // needs no write\n            if (!committed || !_allowanceIsZero(tokenIn, spender)) {\n                tokenIn.safeApproveWithRetry(spender, 0);\n            }\n        }\n    }\n\n    /// @notice Whether `spender`'s allowance on `token` for this contract\n    ///         reads as zero. A failed or short read counts as nonzero, so\n    ///         the caller falls back to clearing it\n    /// @dev    The read gets a fixed gas stipend, not the frame's gas: a token\n    ///         whose `allowance` writes state halts the static frame, and\n    ///         with `gas()` forwarded that halt would burn 63/64 of the race.\n    ///         Within the stipend the read either answers or fails, and a\n    ///         failure means the clear runs as it always did. A token whose\n    ///         `allowance` lies (zero while a real allowance stands) keeps\n    ///         that allowance after a kept execution; only this contract's\n    ///         future balance of that token is exposed, never a user's\n    function _allowanceIsZero(address token, address spender) private view returns (bool zero) {\n        // Same scratch layout as `_approve`: `allowance(address,address)`\n        // from 0x10, `spender` runs into the zero high bytes of the free\n        // memory pointer and is zeroed afterwards\n        assembly (\"memory-safe\") {\n            mstore(0x14, address())\n            mstore(0x34, spender)\n            mstore(0x00, 0xdd62ed3e000000000000000000000000)\n            zero := staticcall(ALLOWANCE_READ_GAS, token, 0x10, 0x44, 0x00, 0x20)\n            zero := and(zero, and(gt(returndatasize(), 0x1f), iszero(mload(0x00))))\n            mstore(0x34, 0)\n        }\n    }\n\n    /// @notice Approve `spender` for `amount` of `token`, reporting failure\n    ///         instead of reverting\n    /// @dev    Mirrors solady's `safeApproveWithRetry`, including the retry\n    ///         after resetting the allowance to zero that tokens like USDT\n    ///         require, but returns false instead of reverting so a single\n    ///         unapprovable route cannot kill an otherwise fillable race\n    /// @return Whether the allowance was set\n    function _tryApprove(address token, address spender, uint256 amount) private returns (bool) {\n        if (_approve(token, spender, amount)) {\n            return true;\n        }\n\n        _approve(token, spender, 0);\n\n        return _approve(token, spender, amount);\n    }\n\n    /// @notice Single `approve` attempt that never reverts\n    /// @dev    Succeeds when the call did and returned nothing (nonstandard\n    ///         tokens) or a first word equal to one, as solady does. Any\n    ///         other return reports failure instead of reverting, so one odd\n    ///         token cannot kill the race. Only the first word is ever read,\n    ///         so a token that returns a lot of data cannot make the race run\n    ///         out of gas on a copy\n    /// @return ok Whether the call succeeded and did not report failure\n    function _approve(address token, address spender, uint256 amount) private returns (bool ok) {\n        // solady's `approve` layout: the payload is the 0x44 bytes from\n        // 0x10, with the selector at 0x10, the `spender` word at 0x14 (its\n        // address bytes at 0x20) and the `amount` word at 0x34. That last\n        // word runs into the free memory pointer's high bytes, which are\n        // always zero, so zeroing it afterwards restores the pointer. The\n        // selector is written last so its zero tail cleans the high bytes\n        // of `spender`. The return word lands at 0x00, read in place\n        assembly (\"memory-safe\") {\n            mstore(0x14, spender)\n            mstore(0x34, amount)\n            mstore(0x00, 0x095ea7b3000000000000000000000000)\n            ok := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            ok := and(ok, or(iszero(returndatasize()), eq(mload(0x00), 1)))\n            mstore(0x34, 0)\n        }\n    }\n\n    /// @notice Copy at most `MAX_REVERT_DATA_BYTES` of the last call's\n    ///         revert data for reporting\n    /// @dev    Same bound as the inline one in `callRoute`. The bytes are\n    ///         allocated here without zero filling: only `size` bytes are\n    ///         ever read, and the event encoder writes its own padding\n    /// @return revertData The (truncated) revert data\n    function _boundedRevertData() private pure returns (bytes memory revertData) {\n        assembly (\"memory-safe\") {\n            let size := returndatasize()\n            if gt(size, MAX_REVERT_DATA_BYTES) {\n                size := MAX_REVERT_DATA_BYTES\n            }\n            revertData := mload(0x40)\n            mstore(revertData, size)\n            returndatacopy(add(revertData, 0x20), 0, size)\n            mstore(0x40, and(add(add(revertData, 0x3f), size), not(0x1f)))\n        }\n    }\n}\n"},"src/common/ReentrancyGuardTransient.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport {ReentrancyGuard} from \"./ReentrancyGuard.sol\";\n\n/// @title  ReentrancyGuardTransient\n/// @notice Reentrancy guard whose lock lives in EIP-1153 transient storage.\n/// @dev    Locking and unlocking costs about 300 gas, against roughly 2,300 for\n///         the storage backed guard on every call after the first (a cold SLOAD\n///         plus two dirty writes) and about 22,100 on the very first one. The\n///         lock clears itself at the end of the transaction, so the unlock only\n///         matters for a second guarded call in the same transaction.\n///\n///         Requires an EVM with `TSTORE` and `TLOAD` (Cancun). Chains without\n///         them get `ReentrancyGuardStorage` instead;\n///         `bash-utils/check-cancun-support.sh` reports which is which.\n///\n///         The lock is a `uint256` rather than a `bool` on purpose. Both compile\n///         to the same `TLOAD` and `TSTORE`, but a `bool` adds a normalization\n///         step on every read and write, measured at about 140 gas per guarded\n///         call and 48 bytes of extra code. Do not narrow the type.\n///\n///         Unlike `ReentrancyGuardStorage`, the slot here is assigned by the\n///         compiler rather than fixed at solady's slot. Transient storage is\n///         cleared at the end of the transaction, so there is nothing for\n///         offchain tooling to inspect afterwards and nothing that depends on\n///         the location.\nabstract contract ReentrancyGuardTransient is ReentrancyGuard {\n    uint256 private transient _locked;\n\n    modifier nonReentrant() override {\n        if (_locked != 0) {\n            revert Reentrancy();\n        }\n\n        _locked = 1;\n\n        _;\n\n        _locked = 0;\n    }\n}\n"},"lib/solady/src/utils/SafeTransferLib.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)\n/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)\n///\n/// @dev Note:\n/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.\n/// - For ERC20s, this implementation won't check that a token has code,\n///   responsibility is delegated to the caller.\nlibrary SafeTransferLib {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev The ETH transfer has failed.\n    error ETHTransferFailed();\n\n    /// @dev The ERC20 `transferFrom` has failed.\n    error TransferFromFailed();\n\n    /// @dev The ERC20 `transfer` has failed.\n    error TransferFailed();\n\n    /// @dev The ERC20 `approve` has failed.\n    error ApproveFailed();\n\n    /// @dev The Permit2 operation has failed.\n    error Permit2Failed();\n\n    /// @dev The Permit2 amount must be less than `2**160 - 1`.\n    error Permit2AmountOverflow();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                         CONSTANTS                          */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.\n    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;\n\n    /// @dev Suggested gas stipend for contract receiving ETH to perform a few\n    /// storage reads and writes, but low enough to prevent griefing.\n    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;\n\n    /// @dev The unique EIP-712 domain domain separator for the DAI token contract.\n    bytes32 internal constant DAI_DOMAIN_SEPARATOR =\n        0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;\n\n    /// @dev The address for the WETH9 contract on Ethereum mainnet.\n    address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;\n\n    /// @dev The canonical Permit2 address.\n    /// [Github](https://github.com/Uniswap/permit2)\n    /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)\n    address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       ETH OPERATIONS                       */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.\n    //\n    // The regular variants:\n    // - Forwards all remaining gas to the target.\n    // - Reverts if the target reverts.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The force variants:\n    // - Forwards with an optional gas stipend\n    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).\n    // - If the target reverts, or if the gas stipend is exhausted,\n    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.\n    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.\n    // - Reverts if the current contract has insufficient balance.\n    //\n    // The try variants:\n    // - Forwards with a mandatory gas stipend.\n    // - Instead of reverting, returns whether the transfer succeeded.\n\n    /// @dev Sends `amount` (in wei) ETH to `to`.\n    function safeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`.\n    function safeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Transfer all the ETH and check if it succeeded or not.\n            if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferETH(address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if lt(selfbalance(), amount) {\n                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.\n    function forceSafeTransferAllETH(address to) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // forgefmt: disable-next-item\n            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {\n                mstore(0x00, to) // Store the address in scratch space.\n                mstore8(0x0b, 0x73) // Opcode `PUSH20`.\n                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.\n                if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.\n            }\n        }\n    }\n\n    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.\n    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.\n    function trySafeTransferAllETH(address to, uint256 gasStipend)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      ERC20 OPERATIONS                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for\n    /// the current contract to manage.\n    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function trySafeTransferFrom(address token, address from, address to, uint256 amount)\n        internal\n        returns (bool success)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x60, amount) // Store the `amount` argument.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.\n            success :=\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from `from` to `to`.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have their entire balance approved for the current contract to manage.\n    function safeTransferAllFrom(address token, address from, address to)\n        internal\n        returns (uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40) // Cache the free memory pointer.\n            mstore(0x40, to) // Store the `to` argument.\n            mstore(0x2c, shl(96, from)) // Store the `from` argument.\n            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.\n            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x60, 0) // Restore the zero slot to zero.\n            mstore(0x40, m) // Restore the free memory pointer.\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransfer(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sends all of ERC20 `token` from the current contract to `to`.\n    /// Reverts upon failure.\n    function safeTransferAll(address token, address to) internal returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.\n            mstore(0x20, address()) // Store the address of the current contract.\n            // Read the balance, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x14, to) // Store the `to` argument.\n            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.\n            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.\n            // Perform the transfer, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// Reverts upon failure.\n    function safeApprove(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, reverting upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                revert(0x1c, 0x04)\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.\n    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,\n    /// then retries the approval again (some tokens, e.g. USDT, requires this).\n    /// Reverts upon failure.\n    function safeApproveWithRetry(address token, address to, uint256 amount) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, to) // Store the `to` argument.\n            mstore(0x34, amount) // Store the `amount` argument.\n            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n            // Perform the approval, retrying upon failure.\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                )\n            ) {\n                mstore(0x34, 0) // Store 0 for the `amount`.\n                mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.\n                pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.\n                mstore(0x34, amount) // Store back the original `amount`.\n                // Retry the approval, reverting upon failure.\n                if iszero(\n                    and(\n                        or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.\n                        call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    )\n                ) {\n                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                    revert(0x1c, 0x04)\n                }\n            }\n            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.\n        }\n    }\n\n    /// @dev Returns the amount of ERC20 `token` owned by `account`.\n    /// Returns zero if the `token` does not exist.\n    function balanceOf(address token, address account) internal view returns (uint256 amount) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            amount :=\n                mul( // The arguments of `mul` are evaluated from right to left.\n                    mload(0x20),\n                    and( // The arguments of `and` are evaluated from right to left.\n                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.\n                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)\n                    )\n                )\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.\n    /// If the initial attempt fails, try to use Permit2 to transfer the token.\n    /// Reverts upon failure.\n    ///\n    /// The `from` account must have at least `amount` approved for the current contract to manage.\n    function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {\n        if (!trySafeTransferFrom(token, from, to, amount)) {\n            permit2TransferFrom(token, from, to, amount);\n        }\n    }\n\n    /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.\n    /// Reverts upon failure.\n    function permit2TransferFrom(address token, address from, address to, uint256 amount)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(add(m, 0x74), shr(96, shl(96, token)))\n            mstore(add(m, 0x54), amount)\n            mstore(add(m, 0x34), to)\n            mstore(add(m, 0x20), shl(96, from))\n            // `transferFrom(address,address,uint160,address)`.\n            mstore(m, 0x36c78516000000000000000000000000)\n            let p := PERMIT2\n            let exists := eq(chainid(), 1)\n            if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }\n            if iszero(and(call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00), exists)) {\n                mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)\n            }\n        }\n    }\n\n    /// @dev Permit a user to spend a given amount of\n    /// another user's tokens via native EIP-2612 permit if possible, falling\n    /// back to Permit2 if native permit fails or is not implemented on the token.\n    function permit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        bool success;\n        /// @solidity memory-safe-assembly\n        assembly {\n            for {} shl(96, xor(token, WETH9)) {} {\n                mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.\n                if iszero(\n                    and( // The arguments of `and` are evaluated from right to left.\n                        lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.\n                        // Gas stipend to limit gas burn for tokens that don't refund gas when\n                        // an non-existing function is called. 5K should be enough for a SLOAD.\n                        staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)\n                    )\n                ) { break }\n                // After here, we can be sure that token is a contract.\n                let m := mload(0x40)\n                mstore(add(m, 0x34), spender)\n                mstore(add(m, 0x20), shl(96, owner))\n                mstore(add(m, 0x74), deadline)\n                if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {\n                    mstore(0x14, owner)\n                    mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.\n                    mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `1` is already stored at `add(m, 0x94)`.\n                    mstore(add(m, 0xb4), and(0xff, v))\n                    mstore(add(m, 0xd4), r)\n                    mstore(add(m, 0xf4), s)\n                    success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)\n                    break\n                }\n                mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.\n                mstore(add(m, 0x54), amount)\n                mstore(add(m, 0x94), and(0xff, v))\n                mstore(add(m, 0xb4), r)\n                mstore(add(m, 0xd4), s)\n                success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)\n                break\n            }\n        }\n        if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);\n    }\n\n    /// @dev Simple permit on the Permit2 contract.\n    function simplePermit2(\n        address token,\n        address owner,\n        address spender,\n        uint256 amount,\n        uint256 deadline,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0x927da105) // `allowance(address,address,address)`.\n            {\n                let addressMask := shr(96, not(0))\n                mstore(add(m, 0x20), and(addressMask, owner))\n                mstore(add(m, 0x40), and(addressMask, token))\n                mstore(add(m, 0x60), and(addressMask, spender))\n                mstore(add(m, 0xc0), and(addressMask, spender))\n            }\n            let p := mul(PERMIT2, iszero(shr(160, amount)))\n            if iszero(\n                and( // The arguments of `and` are evaluated from right to left.\n                    gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.\n                    staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)\n                )\n            ) {\n                mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.\n                revert(add(0x18, shl(2, iszero(p))), 0x04)\n            }\n            mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).\n            // `owner` is already `add(m, 0x20)`.\n            // `token` is already at `add(m, 0x40)`.\n            mstore(add(m, 0x60), amount)\n            mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.\n            // `nonce` is already at `add(m, 0xa0)`.\n            // `spender` is already at `add(m, 0xc0)`.\n            mstore(add(m, 0xe0), deadline)\n            mstore(add(m, 0x100), 0x100) // `signature` offset.\n            mstore(add(m, 0x120), 0x41) // `signature` length.\n            mstore(add(m, 0x140), r)\n            mstore(add(m, 0x160), s)\n            mstore(add(m, 0x180), shl(248, v))\n            if iszero(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"cancun","remappings":["@openzeppelin/=lib/openzeppelin-contracts/","solady/=lib/solady/","permit2-relay/=lib/permit2-relay/","0x-settler/=lib/0x-settler/","trustlessPermit/=lib/trustlessPermit/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/","lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/","lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/","lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/","lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/","lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/","lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/","lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/","lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/","lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/","lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/","lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/","lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/","lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/","lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/","lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/","lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/","lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/","lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/","lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/","lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/","lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/","lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/","lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/","lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/","lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/","lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/","lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/","lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/","lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/","ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/","forge-std/=lib/forge-std/src/","openzeppelin-contracts/=lib/openzeppelin-contracts/","permit2/=lib/0x-settler/lib/permit2/","solmate/=lib/0x-settler/lib/solmate/"]}},"stdJsonOutput":{"sources":{"src/common/ReentrancyGuard.sol":{"id":2},"src/route-racer/RouteRacer.sol":{"id":4},"lib/solady/src/auth/Ownable.sol":{"id":0},"src/route-racer/RouteRacerBase.sol":{"id":5},"src/common/ReentrancyGuardTransient.sol":{"id":3},"lib/solady/src/utils/SafeTransferLib.sol":{"id":1}},"contracts":{"src/route-racer/RouteRacer.sol":{"RouteRacer":{"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AllRoutesFailed","type":"error","inputs":[]},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"ExcessiveRouteValue","type":"error","inputs":[]},{"name":"IdenticalTokens","type":"error","inputs":[]},{"name":"InsufficientOutput","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"}]},{"name":"InvalidMainCount","type":"error","inputs":[{"name":"mainCount","type":"uint256","internalType":"uint256"},{"name":"routeCount","type":"uint256","internalType":"uint256"}]},{"name":"InvalidMsgValue","type":"error","inputs":[]},{"name":"InvalidRecipient","type":"error","inputs":[{"name":"recipient","type":"address","internalType":"address"}]},{"name":"InvalidRouteFee","type":"error","inputs":[{"name":"index","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"}]},{"name":"InvalidRouteTarget","type":"error","inputs":[{"name":"target","type":"address","internalType":"address"}]},{"name":"MinAmountOutRequired","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"NoRoutes","type":"error","inputs":[]},{"name":"OnlySelf","type":"error","inputs":[]},{"name":"RecipientCannotBeZeroAddress","type":"error","inputs":[]},{"name":"Reentrancy","type":"error","inputs":[]},{"name":"RefundToCannotBeZeroAddress","type":"error","inputs":[]},{"name":"RouteApprovalFailed","type":"error","inputs":[]},{"name":"RouteGasLimitRequired","type":"error","inputs":[]},{"name":"TrialResult","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"}]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"ValueOnNativeOutput","type":"error","inputs":[]},{"name":"WinnerUnderperformed","type":"error","inputs":[{"name":"amountOut","type":"uint256","internalType":"uint256"},{"name":"trialAmountOut","type":"uint256","internalType":"uint256"}]},{"name":"OwnershipHandoverCanceled","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipHandoverRequested","type":"event","inputs":[{"name":"pendingOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"oldOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RouteExecutionFailed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"revertData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteRaceWon","type":"event","inputs":[{"name":"index","type":"uint256","indexed":true,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"trialedCount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"mainCount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"metadata","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteTrialFailed","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"revertData","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"RouteTrialSucceeded","type":"event","inputs":[{"name":"index","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"target","type":"address","indexed":true,"internalType":"address"},{"name":"amountOut","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"FEE_DENOMINATOR","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"callRoute","type":"function","inputs":[],"outputs":[{"name":"output","type":"uint256","internalType":"uint256"}],"stateMutability":"nonpayable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"result","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"ownershipHandoverExpiresAt","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[{"name":"result","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"race","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"tokenOut","type":"address","internalType":"address"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"refundTo","type":"address","internalType":"address"},{"name":"routes","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"gasLimit","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"}],"internalType":"struct Route[]"},{"name":"emitEvents","type":"bool","internalType":"bool"},{"name":"metadata","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"winnerIndex","type":"uint256","internalType":"uint256"},{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"raceWithBackups","type":"function","inputs":[{"name":"tokenIn","type":"address","internalType":"address"},{"name":"amountIn","type":"uint256","internalType":"uint256"},{"name":"tokenOut","type":"address","internalType":"address"},{"name":"minAmountOut","type":"uint256","internalType":"uint256"},{"name":"recipient","type":"address","internalType":"address"},{"name":"refundTo","type":"address","internalType":"address"},{"name":"routes","type":"tuple[]","components":[{"name":"target","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"},{"name":"value","type":"uint256","internalType":"uint256"},{"name":"gasLimit","type":"uint256","internalType":"uint256"},{"name":"feePpm","type":"uint256","internalType":"uint256"},{"name":"callData","type":"bytes","internalType":"bytes"}],"internalType":"struct Route[]"},{"name":"mainCount","type":"uint256","internalType":"uint256"},{"name":"emitEvents","type":"bool","internalType":"bool"},{"name":"metadata","type":"bytes","internalType":"bytes"}],"outputs":[{"name":"winnerIndex","type":"uint256","internalType":"uint256"},{"name":"amountOut","type":"uint256","internalType":"uint256"}],"stateMutability":"payable"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"withdraw","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AllRoutesFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"AlreadyInitialized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ExcessiveRouteValue\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"IdenticalTokens\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"}],\"name\":\"InsufficientOutput\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"mainCount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"routeCount\",\"type\":\"uint256\"}],\"name\":\"InvalidMainCount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidMsgValue\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"InvalidRecipient\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePpm\",\"type\":\"uint256\"}],\"name\":\"InvalidRouteFee\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"InvalidRouteTarget\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"MinAmountOutRequired\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewOwnerIsZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoHandoverRequest\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoRoutes\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"OnlySelf\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RecipientCannotBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Reentrancy\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RefundToCannotBeZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RouteApprovalFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"RouteGasLimitRequired\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"TrialResult\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ValueOnNativeOutput\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"trialAmountOut\",\"type\":\"uint256\"}],\"name\":\"WinnerUnderperformed\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverCanceled\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"OwnershipHandoverRequested\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oldOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"RouteExecutionFailed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"trialedCount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"mainCount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"RouteRaceWon\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"revertData\",\"type\":\"bytes\"}],\"name\":\"RouteTrialFailed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"name\":\"RouteTrialSucceeded\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"FEE_DENOMINATOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"callRoute\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"output\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cancelOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"completeOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"result\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"pendingOwner\",\"type\":\"address\"}],\"name\":\"ownershipHandoverExpiresAt\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"result\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenOut\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"refundTo\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePpm\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct Route[]\",\"name\":\"routes\",\"type\":\"tuple[]\"},{\"internalType\":\"bool\",\"name\":\"emitEvents\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"race\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"winnerIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"tokenIn\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amountIn\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"tokenOut\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"minAmountOut\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"refundTo\",\"type\":\"address\"},{\"components\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"gasLimit\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"feePpm\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"callData\",\"type\":\"bytes\"}],\"internalType\":\"struct Route[]\",\"name\":\"routes\",\"type\":\"tuple[]\"},{\"internalType\":\"uint256\",\"name\":\"mainCount\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"emitEvents\",\"type\":\"bool\"},{\"internalType\":\"bytes\",\"name\":\"metadata\",\"type\":\"bytes\"}],\"name\":\"raceWithBackups\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"winnerIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountOut\",\"type\":\"uint256\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requestOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"withdraw\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"The default. Requires Cancun; use `RouteRacer_NonTstore` on chains         without transient storage.\",\"errors\":{\"AlreadyInitialized()\":[{\"details\":\"Cannot double-initialize.\"}],\"NewOwnerIsZeroAddress()\":[{\"details\":\"The `newOwner` cannot be the zero address.\"}],\"NoHandoverRequest()\":[{\"details\":\"The `pendingOwner` does not have a valid handover request.\"}],\"Unauthorized()\":[{\"details\":\"The caller is not authorized to call the function.\"}]},\"events\":{\"OwnershipHandoverCanceled(address)\":{\"details\":\"The ownership handover to `pendingOwner` has been canceled.\"},\"OwnershipHandoverRequested(address)\":{\"details\":\"An ownership handover to `pendingOwner` has been requested.\"},\"OwnershipTransferred(address,address)\":{\"details\":\"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event.\"},\"RouteExecutionFailed(uint256,address,bytes)\":{\"params\":{\"index\":\"The index of the failed route in `routes`, where anything        at or above the race's `mainCount` is a backup\",\"revertData\":\"The (truncated) revert data of the failed execution\",\"target\":\"The swap provider router that was called\"}},\"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)\":{\"params\":{\"amountOut\":\"The actual executed output delivered to the recipient\",\"index\":\"The index of the winning route in `routes`, where        anything at or above the race's `mainCount` is a backup\",\"mainCount\":\"How many of `routes` were mains: `routes.length` on        `race`, the caller's `mainCount` on `raceWithBackups`. With it        the event alone tells a rescue (`index >= mainCount`) from a        main's win and whether the backups ran at all (`trialedCount >        mainCount`), without reading the race calldata\",\"metadata\":\"Additional data to associate the race to\",\"target\":\"The swap provider router of the winning route\",\"trialedCount\":\"How many candidates were actually trialed, always a        prefix of `routes`. Equals `mainCount` when the mains filled the        race and the backups were never reached, so a consumer can tell        a skipped candidate from a failed one instead of undercounting        from the trial events\"}},\"RouteTrialFailed(uint256,address,bytes)\":{\"params\":{\"index\":\"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup\",\"revertData\":\"The (truncated) revert data of the failed trial\",\"target\":\"The swap provider router that was called\"}},\"RouteTrialSucceeded(uint256,address,uint256)\":{\"params\":{\"amountOut\":\"The measured output of the trial\",\"index\":\"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup. A backup that the race        never reached emits nothing, so use `trialedCount` on        `RouteRaceWon` rather than counting these events to know how        many candidates were tried. Not indexed: a consumer filters by        race transaction, never by route index, and the topic cost more        than the data word\",\"target\":\"The swap provider router that was called\"}}},\"kind\":\"dev\",\"methods\":{\"callRoute()\":{\"details\":\"Only callable by this contract itself (via `_callRoute`), which         is load bearing: the balance snapshot is an input, so a forged         snapshot of zero would report the contract's whole `tokenOut`         balance as one route's output. Takes no ABI arguments:         `_callRoute` writes a fixed layout payload after the selector         and this reads it back at the same offsets (GAS.md step 18).         Layout, offsets from the start of calldata:           0x004  isTrial           0x024  threshold (commit threshold for a trial, the trial                  claimed output for the winner)           0x044  tokenIn           0x064  amountIn           0x084  tokenOut           0x0a4  outBalanceBefore           0x0c4  target, spender, value, gasLimit (the route head)           0x144  callData length           0x164  callData bytes\"},\"cancelOwnershipHandover()\":{\"details\":\"Cancels the two-step ownership handover to the caller, if any.\"},\"completeOwnershipHandover(address)\":{\"details\":\"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`.\"},\"owner()\":{\"details\":\"Returns the owner of the contract.\"},\"ownershipHandoverExpiresAt(address)\":{\"details\":\"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.\"},\"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)\":{\"details\":\"The caller must have approved this contract for `amountIn` of         `tokenIn` (or send it as msg.value when `tokenIn` is native).         Swap calldata must be built with this contract as taker/recipient         so outputs land here and can be measured. Among the routes         whose raw output clears `minAmountOut` the one with the         highest output net of its `feePpm` wins; a route below the         floor never wins over one that clears it, whatever its net.         The last candidate keeps its own execution when its raw         output already matches every earlier trial net of fees and         clears the floor, which fills the race without a second         execution, so order candidates worst to best by expected net         output to hit that path. Among the other candidates an exact         tie on net output goes to the route whose trial used less         gas, not to the earlier one. Otherwise candidates are         executed in descending net output order: an execution that         fails or delivers less than its trial output is rolled back         and the next-best route is tried instead. Reverts if every         route fails, no trial output clears `minAmountOut`, or every         candidate's execution fails. Leftover native and unspent         input tokens are refunded to `refundTo`.         Every route here is a main: all of them are trialed. To hold         some routes back as backups, call `raceWithBackups`.\",\"params\":{\"amountIn\":\"The input amount\",\"emitEvents\":\"Whether to emit per-trial and winner events\",\"metadata\":\"Additional data to associate the race to\",\"minAmountOut\":\"The minimum acceptable executed output (must be > 0)\",\"recipient\":\"The address to receive the winning output\",\"refundTo\":\"The address to refund any leftover funds to\",\"routes\":\"The candidate swap routes to race. Must not be empty\",\"tokenIn\":\"The input token (address(0) for native)\",\"tokenOut\":\"The output token (address(0) for native, must differ from `tokenIn`)\"},\"returns\":{\"amountOut\":\"The actual output delivered to the recipient\",\"winnerIndex\":\"The index of the executed route\"}},\"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)\":{\"details\":\"Identical to `race` except that only the first `mainCount`         routes are trialed up front. The rest are reached only when         the mains leave the race unfillable, meaning none of them         succeeded, the best of them is below `minAmountOut`, or every         main that cleared it failed its real execution, so a race         whose mains fill never pays to trial a backup. A backup         is a guard against a main failing, not against a main being         mispriced: a main that clears the floor wins even where a         backup would have paid more. Backups are not raced against         each other either: they are trialed in order and the first         that clears `minAmountOut` is executed, as its trial, so order         them most reliable first. Both lists share one index space,         mains first, so any index at or above `mainCount` is a backup.\",\"params\":{\"amountIn\":\"The input amount\",\"emitEvents\":\"Whether to emit per-trial and winner events\",\"mainCount\":\"How many of `routes` are mains. Must be nonzero and no        greater than `routes.length`; equal to it means no backups,        which is exactly `race`. The rest are tried in order until one        clears the floor\",\"metadata\":\"Additional data to associate the race to\",\"minAmountOut\":\"The minimum acceptable executed output (must be > 0).        This is doing double duty: it is both the caller's protection        floor and the trigger for the backup routes, which are only        trialed when the mains cannot clear it. Raising it therefore        makes backups fire more often and also makes more fills revert,        so choose it with both effects in mind\",\"recipient\":\"The address to receive the winning output\",\"refundTo\":\"The address to refund any leftover funds to\",\"routes\":\"Every candidate, mains first then the backups. Must not        be empty\",\"tokenIn\":\"The input token (address(0) for native)\",\"tokenOut\":\"The output token (address(0) for native, must differ from `tokenIn`)\"},\"returns\":{\"amountOut\":\"The actual output delivered to the recipient\",\"winnerIndex\":\"The index of the executed route in `routes`, where         anything at or above `mainCount` is a backup\"}},\"renounceOwnership()\":{\"details\":\"Allows the owner to renounce their ownership.\"},\"requestOwnershipHandover()\":{\"details\":\"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default.\"},\"transferOwnership(address)\":{\"details\":\"Allows the owner to transfer the ownership to `newOwner`.\"},\"withdraw(address,address)\":{\"details\":\"Sweeps the whole balance. `onlyOwner`, so naming a recipient         grants nothing the owner could not already do by withdrawing to         themselves and transferring on; it only saves that second step\",\"params\":{\"to\":\"The address to send it to\",\"token\":\"The token to sweep, or address(0) for the native balance\"}}},\"title\":\"RouteRacer\",\"version\":1},\"userdoc\":{\"errors\":{\"AllRoutesFailed()\":[{\"notice\":\"Revert if every route's trial failed\"}],\"ExcessiveRouteValue()\":[{\"notice\":\"Recorded as a route's trial failure reason when its `value`         exceeds the native value provided by the caller for this fill\"}],\"IdenticalTokens()\":[{\"notice\":\"Revert if `tokenIn` and `tokenOut` are the same token, which         would break the balance-delta output measurement\"}],\"InsufficientOutput(uint256,uint256)\":[{\"notice\":\"Revert if the best trial output is below the minimum\"}],\"InvalidMainCount(uint256,uint256)\":[{\"notice\":\"Revert if `mainCount` is zero, which would trial nothing, or         exceeds the number of routes supplied\"}],\"InvalidMsgValue()\":[{\"notice\":\"Revert if msg.value does not cover a native `amountIn`\"}],\"InvalidRecipient(address)\":[{\"notice\":\"Revert if the recipient is this contract\"}],\"InvalidRouteFee(uint256,uint256)\":[{\"notice\":\"Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.         A fee of the whole output leaves nothing to rank and would         divide by zero in the commit threshold\"}],\"InvalidRouteTarget(address)\":[{\"notice\":\"Revert if a route targets this contract, which would make the         contract its own caller and satisfy the `OnlySelf` gate on         `callRoute`\"}],\"MinAmountOutRequired()\":[{\"notice\":\"Revert if `minAmountOut` is zero, which would disable the theft guard\"}],\"NoRoutes()\":[{\"notice\":\"Revert if no routes are provided\"}],\"OnlySelf()\":[{\"notice\":\"Revert if `callRoute` is called by anyone other than this contract\"}],\"RecipientCannotBeZeroAddress()\":[{\"notice\":\"Revert if a recipient is the zero address, either the race's         `recipient` or a `withdraw` destination\"}],\"Reentrancy()\":[{\"notice\":\"Unauthorized reentrant call\"}],\"RefundToCannotBeZeroAddress()\":[{\"notice\":\"Revert if the refundTo address is the zero address\"}],\"RouteApprovalFailed()\":[{\"notice\":\"Recorded as a route's trial failure reason when `tokenIn`         cannot be approved for the route's spender\"}],\"RouteGasLimitRequired()\":[{\"notice\":\"Revert if a route's `gasLimit` is zero, which would let it         starve the other trials and the winner's execution\"}],\"TrialResult(uint256)\":[{\"notice\":\"Used as the success signal of a trial subcall, never a real failure\"}],\"ValueOnNativeOutput()\":[{\"notice\":\"Recorded as a route's trial failure reason when the output is         native and the route would forward native value. Output is         measured as this contract's native balance delta, so any of         that value the provider hands back would count as swap output:         a refunded fee would go to the recipient instead of `refundTo`,         `minAmountOut` would stop being a guarantee, and a route that         simply returned what it was given could beat one that swaps\"}],\"WinnerUnderperformed(uint256,uint256)\":[{\"notice\":\"Revert if the winner's executed output is below its trial-claimed output\"}]},\"events\":{\"RouteExecutionFailed(uint256,address,bytes)\":{\"notice\":\"Emitted when a selected route's real execution fails or         under-delivers and is rolled back, before the race falls back         to the next-best route (when `emitEvents` is set)\"},\"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)\":{\"notice\":\"Emitted after the winning route is executed (when `emitEvents` is set)\"},\"RouteTrialFailed(uint256,address,bytes)\":{\"notice\":\"Emitted for each route trial that failed (when `emitEvents` is         set)\"},\"RouteTrialSucceeded(uint256,address,uint256)\":{\"notice\":\"Emitted for each route trial that succeeded (when `emitEvents`         is set)\"}},\"kind\":\"user\",\"methods\":{\"FEE_DENOMINATOR()\":{\"notice\":\"The unit of `Route.feePpm`: a fee of this many parts is the         whole output. Parts per million, so a basis point is 100 and         a deal quoted in fractions of a basis point still fits\"},\"callRoute()\":{\"notice\":\"Run one route in its own call frame and measure its output.         A trial reverts with `TrialResult(output)` so that everything         the route did is discarded, unless the output clears the commit         threshold, in which case the frame returns the output and keeps         the execution. The winner's execution returns its output when         that is at least the trial's claim and reverts with         `WinnerUnderperformed` otherwise, so the race can roll it back\"},\"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)\":{\"notice\":\"Pull `amountIn` of `tokenIn` from the caller, trial every route,         execute the one with the highest output net of its fee and         deliver its raw output of `tokenOut` to `recipient`\"},\"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)\":{\"notice\":\"`race`, with the tail of `routes` held back as backups that are         trialed only when the mains cannot fill the order\"},\"withdraw(address,address)\":{\"notice\":\"Withdraw funds that got stuck in the contract\"}},\"notice\":\"`RouteRacerBase` with the reentrancy lock in transient storage.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/route-racer/RouteRacer.sol\":\"RouteRacer\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[\":0x-settler/=lib/0x-settler/\",\":@openzeppelin/=lib/openzeppelin-contracts/\",\":ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/\",\":forge-std/=lib/forge-std/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/\",\":permit2-relay/=lib/permit2-relay/\",\":permit2/=lib/0x-settler/lib/permit2/\",\":solady/=lib/solady/\",\":solmate/=lib/0x-settler/lib/solmate/\",\":trustlessPermit/=lib/trustlessPermit/\",\"lib/0x-settler/:forge-gas-snapshot/=lib/0x-settler/lib/forge-gas-snapshot/src/\",\"lib/0x-settler/:forge-std/=lib/0x-settler/lib/forge-std/src/\",\"lib/0x-settler/:solmate/=lib/0x-settler/lib/solmate/\",\"lib/0x-settler/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/src/\",\"lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/\",\"lib/0x-settler/lib/forge-std/:ds-test/=lib/0x-settler/lib/forge-std/lib/ds-test/src/\",\"lib/0x-settler/lib/permit2/:forge-gas-snapshot/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/src/\",\"lib/0x-settler/lib/permit2/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-std/src/\",\"lib/0x-settler/lib/permit2/:openzeppelin-contracts/=lib/0x-settler/lib/permit2/lib/openzeppelin-contracts/\",\"lib/0x-settler/lib/permit2/:solmate/=lib/0x-settler/lib/permit2/lib/solmate/\",\"lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/:forge-std/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/src/\",\"lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/\",\"lib/0x-settler/lib/permit2/lib/forge-std/:ds-test/=lib/0x-settler/lib/permit2/lib/forge-std/lib/ds-test/src/\",\"lib/0x-settler/lib/permit2/lib/solmate/:ds-test/=lib/0x-settler/lib/permit2/lib/solmate/lib/ds-test/src/\",\"lib/0x-settler/lib/solmate/:ds-test/=lib/0x-settler/lib/solmate/lib/ds-test/src/\",\"lib/openzeppelin-contracts/:forge-std/=lib/openzeppelin-contracts/lib/forge-std/src/\",\"lib/openzeppelin-contracts/lib/forge-std/:ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/\",\"lib/permit2-relay/:forge-gas-snapshot/=lib/permit2-relay/lib/forge-gas-snapshot/src/\",\"lib/permit2-relay/:forge-std/=lib/permit2-relay/lib/forge-std/src/\",\"lib/permit2-relay/:openzeppelin-contracts/=lib/permit2-relay/lib/openzeppelin-contracts/\",\"lib/permit2-relay/:solmate/=lib/permit2-relay/lib/solmate/\",\"lib/permit2-relay/lib/forge-gas-snapshot/:forge-std/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/src/\",\"lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-gas-snapshot/lib/forge-std/lib/ds-test/src/\",\"lib/permit2-relay/lib/forge-std/:ds-test/=lib/permit2-relay/lib/forge-std/lib/ds-test/src/\",\"lib/permit2-relay/lib/solmate/:ds-test/=lib/permit2-relay/lib/solmate/lib/ds-test/src/\"],\"viaIR\":true},\"sources\":{\"lib/solady/src/auth/Ownable.sol\":{\"keccak256\":\"0xc208cdd9de02bbf4b5edad18b88e23a2be7ff56d2287d5649329dc7cda64b9a3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e8fba079cc7230c617f7493a2e97873f88e59a53a5018fcb2e2b6ac42d8aa5a3\",\"dweb:/ipfs/QmTXg8GSt8hsK2cZhbPFrund1mrwVdkLQmEPoQaFy4fhjs\"]},\"lib/solady/src/utils/SafeTransferLib.sol\":{\"keccak256\":\"0x583f47701d9b47bb3ef80fcabbbd62fbb58a01733b7a57e19658b4b02468883a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://2523bfac005e21ef9963fdb3c08b2c61824e2b5ce2f53d1a1828b01ed995217c\",\"dweb:/ipfs/QmbBjVG9tZyeZSQH4m5GUzNBwo2iuvLoZYbmhT4gxnJc4J\"]},\"src/common/ReentrancyGuard.sol\":{\"keccak256\":\"0xa692f06a785ef1ad64199597777c89af8398a175565c2d93c13a75d712ae574d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://eb998af38f7c17a16a9b201065cf34c14c6a148537a35c03f1119f1d02069b74\",\"dweb:/ipfs/QmWnK6SaWS28yCmvwg5THsmqcPfRf8shQaystVX3XZqUVe\"]},\"src/common/ReentrancyGuardTransient.sol\":{\"keccak256\":\"0x8485fb154198103d4b3f0a0ab0106d81a4d109cef1e3ebf37f67556b65de0382\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b26d695069d749b12730659fb2fd9230dcd0d8371851dab0f34eb0e78f52c265\",\"dweb:/ipfs/QmUz4jdb28vdD9722UKuDWEHB9ah4H2FuDKAL4yF88gk5x\"]},\"src/route-racer/RouteRacer.sol\":{\"keccak256\":\"0xd171e03eb79a155499efb4a15acc5631c2333d5ed1fefef660609199c1824745\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://57dc8d8da385b2e56168b82a1d71d84d2ba9147b6a7f74044f686135bf723878\",\"dweb:/ipfs/QmTzFQyNpn64CPYyCwZG2fzqwpXe2CogHcurNUrjteGWhu\"]},\"src/route-racer/RouteRacerBase.sol\":{\"keccak256\":\"0xddbc9e663e03d77fa87c7ea7368931798649e8e5305c078e23a681d8966439b9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://546b1dd1eb51e299d248c3957ff211cbcff527ffa7cea180a659eef70abac28e\",\"dweb:/ipfs/QmaXdqFdKjWasbYa3z17ng3Vbpv8SPpnfRmVKkGNXvFrbw\"]}},\"version\":1}","userdoc":{"kind":"user","errors":{"NoRoutes()":[{"notice":"Revert if no routes are provided"}],"OnlySelf()":[{"notice":"Revert if `callRoute` is called by anyone other than this contract"}],"Reentrancy()":[{"notice":"Unauthorized reentrant call"}],"AllRoutesFailed()":[{"notice":"Revert if every route's trial failed"}],"IdenticalTokens()":[{"notice":"Revert if `tokenIn` and `tokenOut` are the same token, which         would break the balance-delta output measurement"}],"InvalidMsgValue()":[{"notice":"Revert if msg.value does not cover a native `amountIn`"}],"TrialResult(uint256)":[{"notice":"Used as the success signal of a trial subcall, never a real failure"}],"ExcessiveRouteValue()":[{"notice":"Recorded as a route's trial failure reason when its `value`         exceeds the native value provided by the caller for this fill"}],"RouteApprovalFailed()":[{"notice":"Recorded as a route's trial failure reason when `tokenIn`         cannot be approved for the route's spender"}],"ValueOnNativeOutput()":[{"notice":"Recorded as a route's trial failure reason when the output is         native and the route would forward native value. Output is         measured as this contract's native balance delta, so any of         that value the provider hands back would count as swap output:         a refunded fee would go to the recipient instead of `refundTo`,         `minAmountOut` would stop being a guarantee, and a route that         simply returned what it was given could beat one that swaps"}],"MinAmountOutRequired()":[{"notice":"Revert if `minAmountOut` is zero, which would disable the theft guard"}],"RouteGasLimitRequired()":[{"notice":"Revert if a route's `gasLimit` is zero, which would let it         starve the other trials and the winner's execution"}],"InvalidRecipient(address)":[{"notice":"Revert if the recipient is this contract"}],"InvalidRouteTarget(address)":[{"notice":"Revert if a route targets this contract, which would make the         contract its own caller and satisfy the `OnlySelf` gate on         `callRoute`"}],"RefundToCannotBeZeroAddress()":[{"notice":"Revert if the refundTo address is the zero address"}],"RecipientCannotBeZeroAddress()":[{"notice":"Revert if a recipient is the zero address, either the race's         `recipient` or a `withdraw` destination"}],"InvalidRouteFee(uint256,uint256)":[{"notice":"Revert if a route's `feePpm` is not below `FEE_DENOMINATOR`.         A fee of the whole output leaves nothing to rank and would         divide by zero in the commit threshold"}],"InvalidMainCount(uint256,uint256)":[{"notice":"Revert if `mainCount` is zero, which would trial nothing, or         exceeds the number of routes supplied"}],"InsufficientOutput(uint256,uint256)":[{"notice":"Revert if the best trial output is below the minimum"}],"WinnerUnderperformed(uint256,uint256)":[{"notice":"Revert if the winner's executed output is below its trial-claimed output"}]},"events":{"RouteTrialFailed(uint256,address,bytes)":{"notice":"Emitted for each route trial that failed (when `emitEvents` is         set)"},"RouteExecutionFailed(uint256,address,bytes)":{"notice":"Emitted when a selected route's real execution fails or         under-delivers and is rolled back, before the race falls back         to the next-best route (when `emitEvents` is set)"},"RouteTrialSucceeded(uint256,address,uint256)":{"notice":"Emitted for each route trial that succeeded (when `emitEvents`         is set)"},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"notice":"Emitted after the winning route is executed (when `emitEvents` is set)"}},"notice":"`RouteRacerBase` with the reentrancy lock in transient storage.","methods":{"callRoute()":{"notice":"Run one route in its own call frame and measure its output.         A trial reverts with `TrialResult(output)` so that everything         the route did is discarded, unless the output clears the commit         threshold, in which case the frame returns the output and keeps         the execution. The winner's execution returns its output when         that is at least the trial's claim and reverts with         `WinnerUnderperformed` otherwise, so the race can roll it back"},"FEE_DENOMINATOR()":{"notice":"The unit of `Route.feePpm`: a fee of this many parts is the         whole output. Parts per million, so a basis point is 100 and         a deal quoted in fractions of a basis point still fits"},"withdraw(address,address)":{"notice":"Withdraw funds that got stuck in the contract"},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"notice":"Pull `amountIn` of `tokenIn` from the caller, trial every route,         execute the one with the highest output net of its fee and         deliver its raw output of `tokenOut` to `recipient`"},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"notice":"`race`, with the tail of `routes` held back as backups that are         trialed only when the mains cannot fill the order"}},"version":1},"devdoc":{"kind":"dev","title":"RouteRacer","errors":{"Unauthorized()":[{"details":"The caller is not authorized to call the function."}],"NoHandoverRequest()":[{"details":"The `pendingOwner` does not have a valid handover request."}],"AlreadyInitialized()":[{"details":"Cannot double-initialize."}],"NewOwnerIsZeroAddress()":[{"details":"The `newOwner` cannot be the zero address."}]},"events":{"OwnershipHandoverCanceled(address)":{"details":"The ownership handover to `pendingOwner` has been canceled."},"OwnershipHandoverRequested(address)":{"details":"An ownership handover to `pendingOwner` has been requested."},"OwnershipTransferred(address,address)":{"details":"The ownership is transferred from `oldOwner` to `newOwner`. This event is intentionally kept the same as OpenZeppelin's Ownable to be compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173), despite it not being as lightweight as a single argument event."},"RouteTrialFailed(uint256,address,bytes)":{"params":{"index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup","target":"The swap provider router that was called","revertData":"The (truncated) revert data of the failed trial"}},"RouteExecutionFailed(uint256,address,bytes)":{"params":{"index":"The index of the failed route in `routes`, where anything        at or above the race's `mainCount` is a backup","target":"The swap provider router that was called","revertData":"The (truncated) revert data of the failed execution"}},"RouteTrialSucceeded(uint256,address,uint256)":{"params":{"index":"The index of the route in `routes`, where anything at or        above the race's `mainCount` is a backup. A backup that the race        never reached emits nothing, so use `trialedCount` on        `RouteRaceWon` rather than counting these events to know how        many candidates were tried. Not indexed: a consumer filters by        race transaction, never by route index, and the topic cost more        than the data word","target":"The swap provider router that was called","amountOut":"The measured output of the trial"}},"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)":{"params":{"index":"The index of the winning route in `routes`, where        anything at or above the race's `mainCount` is a backup","target":"The swap provider router of the winning route","metadata":"Additional data to associate the race to","amountOut":"The actual executed output delivered to the recipient","mainCount":"How many of `routes` were mains: `routes.length` on        `race`, the caller's `mainCount` on `raceWithBackups`. With it        the event alone tells a rescue (`index >= mainCount`) from a        main's win and whether the backups ran at all (`trialedCount >        mainCount`), without reading the race calldata","trialedCount":"How many candidates were actually trialed, always a        prefix of `routes`. Equals `mainCount` when the mains filled the        race and the backups were never reached, so a consumer can tell        a skipped candidate from a failed one instead of undercounting        from the trial events"}}},"details":"The default. Requires Cancun; use `RouteRacer_NonTstore` on chains         without transient storage.","methods":{"owner()":{"details":"Returns the owner of the contract."},"callRoute()":{"details":"Only callable by this contract itself (via `_callRoute`), which         is load bearing: the balance snapshot is an input, so a forged         snapshot of zero would report the contract's whole `tokenOut`         balance as one route's output. Takes no ABI arguments:         `_callRoute` writes a fixed layout payload after the selector         and this reads it back at the same offsets (GAS.md step 18).         Layout, offsets from the start of calldata:           0x004  isTrial           0x024  threshold (commit threshold for a trial, the trial                  claimed output for the winner)           0x044  tokenIn           0x064  amountIn           0x084  tokenOut           0x0a4  outBalanceBefore           0x0c4  target, spender, value, gasLimit (the route head)           0x144  callData length           0x164  callData bytes"},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"withdraw(address,address)":{"params":{"to":"The address to send it to","token":"The token to sweep, or address(0) for the native balance"},"details":"Sweeps the whole balance. `onlyOwner`, so naming a recipient         grants nothing the owner could not already do by withdrawing to         themselves and transferring on; it only saves that second step"},"requestOwnershipHandover()":{"details":"Request a two-step ownership handover to the caller. The request will automatically expire in 48 hours (172800 seconds) by default."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."},"completeOwnershipHandover(address)":{"details":"Allows the owner to complete the two-step ownership handover to `pendingOwner`. Reverts if there is no existing ownership handover requested by `pendingOwner`."},"ownershipHandoverExpiresAt(address)":{"details":"Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`."},"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)":{"params":{"routes":"The candidate swap routes to race. Must not be empty","tokenIn":"The input token (address(0) for native)","amountIn":"The input amount","metadata":"Additional data to associate the race to","refundTo":"The address to refund any leftover funds to","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)","recipient":"The address to receive the winning output","emitEvents":"Whether to emit per-trial and winner events","minAmountOut":"The minimum acceptable executed output (must be > 0)"},"details":"The caller must have approved this contract for `amountIn` of         `tokenIn` (or send it as msg.value when `tokenIn` is native).         Swap calldata must be built with this contract as taker/recipient         so outputs land here and can be measured. Among the routes         whose raw output clears `minAmountOut` the one with the         highest output net of its `feePpm` wins; a route below the         floor never wins over one that clears it, whatever its net.         The last candidate keeps its own execution when its raw         output already matches every earlier trial net of fees and         clears the floor, which fills the race without a second         execution, so order candidates worst to best by expected net         output to hit that path. Among the other candidates an exact         tie on net output goes to the route whose trial used less         gas, not to the earlier one. Otherwise candidates are         executed in descending net output order: an execution that         fails or delivers less than its trial output is rolled back         and the next-best route is tried instead. Reverts if every         route fails, no trial output clears `minAmountOut`, or every         candidate's execution fails. Leftover native and unspent         input tokens are refunded to `refundTo`.         Every route here is a main: all of them are trialed. To hold         some routes back as backups, call `raceWithBackups`.","returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route"}},"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)":{"params":{"routes":"Every candidate, mains first then the backups. Must not        be empty","tokenIn":"The input token (address(0) for native)","amountIn":"The input amount","metadata":"Additional data to associate the race to","refundTo":"The address to refund any leftover funds to","tokenOut":"The output token (address(0) for native, must differ from `tokenIn`)","mainCount":"How many of `routes` are mains. Must be nonzero and no        greater than `routes.length`; equal to it means no backups,        which is exactly `race`. The rest are tried in order until one        clears the floor","recipient":"The address to receive the winning output","emitEvents":"Whether to emit per-trial and winner events","minAmountOut":"The minimum acceptable executed output (must be > 0).        This is doing double duty: it is both the caller's protection        floor and the trigger for the backup routes, which are only        trialed when the mains cannot clear it. Raising it therefore        makes backups fire more often and also makes more fills revert,        so choose it with both effects in mind"},"details":"Identical to `race` except that only the first `mainCount`         routes are trialed up front. The rest are reached only when         the mains leave the race unfillable, meaning none of them         succeeded, the best of them is below `minAmountOut`, or every         main that cleared it failed its real execution, so a race         whose mains fill never pays to trial a backup. A backup         is a guard against a main failing, not against a main being         mispriced: a main that clears the floor wins even where a         backup would have paid more. Backups are not raced against         each other either: they are trialed in order and the first         that clears `minAmountOut` is executed, as its trial, so order         them most reliable first. Both lists share one index space,         mains first, so any index at or above `mainCount` is a backup.","returns":{"amountOut":"The actual output delivered to the recipient","winnerIndex":"The index of the executed route in `routes`, where         anything at or above `mainCount` is a backup"}}},"version":1},"storageLayout":{"types":null,"storage":[]},"transientStorageLayout":{"types":{"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_uint256","astId":545,"label":"_locked","offset":0,"contract":"src/route-racer/RouteRacer.sol:RouteRacer"}]},"evm":{"bytecode":{"object":"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","sourceMap":"411:125:4:-:0;;;;;;;;;;;;;-1:-1:-1;;411:125:4;;;;-1:-1:-1;;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;411:125:4;;;;;;;;5710:347:0;;;;-1:-1:-1;5710:347:0;;;;411:125:4;;;;;;;;;;-1:-1:-1;411:125:4;;;;;;-1:-1:-1;411:125:4;;;;;-1:-1:-1;411:125:4","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"411:125:4:-:0;;;;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11885:237:0;;;411:125:4;11885:237:0;411:125:4;11885:237:0;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;12478:70:0;;:::i;:::-;12548:16:5;12544:84;;411:125:4;;;;;12696:21:5;;;;;;:::i;12638:176::-;12772:30;12796:4;12772:30;12796:4;12772:30;;:::i;:::-;;;:::i;12544:84::-;12587:30;411:125:4;12587:30:5;411:125:4;;12587:30:5;411:125:4;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;8479:183::-;;411:125:4;8479:183:0;411:125:4;8479:183:0;;411:125:4;;;;;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;411:125:4;10506:526:0;411:125:4;10506:526:0;;;;;;;;;411:125:4;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;411:125:4;10506:526:0;411:125:4;10506:526:0;;411:125:4;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;1638:62:3;;411:125:4;;18941:136:5;411:125:4;;;;;;;;;;;18941:136:5;;:::i;:::-;411:125:4;;;;;;;;;;;;;1638:62:3;1677:12;411:125:4;1677:12:3;411:125:4;;1677:12:3;411:125:4;;;;;;;;;;;;;;11647:9:5;411:125:4;;;;;;;;;;;;;:::i;:::-;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;1638:62:3;;411:125:4;;22112:132:5;411:125:4;;;;;;;;;;;;22112:132:5;;:::i;411:125:4:-;;;;;;;;;;;;11523:61:0;;411:125:4;;;;;;;;;;;;;;;;12478:70:0;;:::i;:::-;411:125:4;6813:405:0;;;;;;411:125:4;6813:405:0;;411:125:4;;;;;;;;;9831:339:0;;;;411:125:4;9831:339:0;411:125:4;9831:339:0;;;;;;411:125:4;9831:339:0;;411:125:4;;;;;;;;;9239:383:0;;;;411:125:4;9239:383:0;7972:9;9132:15;411:125:4;9239:383:0;;;;;;411:125:4;9239:383:0;;411:125:4;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;44212:4044:5;44303:4;44281:10;:27;44277:75;;44620:920;;;;;;;;;;;;411:125:4;;;;45770:22:5;;44620:920;;;;;;;;;45770:22;45766:78;;44212:4044;46026:8;;;:33;;;;44212:4044;46026:58;;;44212:4044;46094:92;;;44212:4044;46413:716;-1:-1:-1;46413:716:5;;;;;;;;;;;;44620:920;;;;46413:716;;;;47474:31;47220:53;;;;;;;;44212:4044;47216:124;;44212:4044;-1:-1:-1;;47373:82:5;;;47398:21;;47474:31;:::i;:::-;47516:389;;;48159:18;;;48155:95;;44212:4044;:::o;48155:95::-;48200:39;;-1:-1:-1;48200:39:5;44620:920;411:125:4;44620:920:5;411:125:4;44620:920:5;-1:-1:-1;48200:39:5;47516:389;47770:14;;;:37;;;;47516:389;47766:89;;;47875:19;;-1:-1:-1;47875:19:5;44620:920;411:125:4;44620:920:5;-1:-1:-1;47875:19:5;47766:89;47827:13::o;47770:37::-;47788:19;;;;;47770:37;;;47373:82;47422:33;44303:4;;47422:33;;:::i;:::-;47474:31;:::i;47216:124::-;47289:40;;;:::i;:::-;47216:124;;;;47220:53;47239:34;;;;;:::i;:::-;47238:35;47220:53;;46413:716;;;;;;;;;;-1:-1:-1;46413:716:5;;;;;;-1:-1:-1;46413:716:5;;46094:92;17644:1483:1;;;;;;;-1:-1:-1;17644:1483:1;;-1:-1:-1;44620:920:5;17644:1483:1;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;46094:92:5;17644:1483:1;-1:-1:-1;17644:1483:1;;46094:92:5;;;17644:1483:1;-1:-1:-1;17644:1483:1;;;-1:-1:-1;17644:1483:1;-1:-1:-1;17644:1483:1;44620:920:5;17644:1483:1;;;;;;;;;-1:-1:-1;44620:920:5;17644:1483:1;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;;;;;;-1:-1:-1;17644:1483:1;44620:920:5;17644:1483:1;;46026:58:5;46063:21;;;;-1:-1:-1;46026:58:5;;:33;411:125:4;;;46038:21:5;;;-1:-1:-1;46026:33:5;;45766:78;45808:25;;;;:::i;:::-;45766:78;;;;44277:75;44331:10;;;;;;17509:1624:1;;17644:1483;;-1:-1:-1;17644:1483:1;;;-1:-1:-1;17644:1483:1;;-1:-1:-1;17644:1483:1;;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;17509:1624;17644:1483;-1:-1:-1;17644:1483:1;;17509:1624::o;17644:1483::-;-1:-1:-1;17644:1483:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17644:1483:1;;;;;;;;;;55746:668:5;56047:361;;;55746:668;56047:361;55746:668;56047:361;;;;;;;;;;;;;;;;;;;;;;55746:668::o;19260:739:1:-;19403:590;;;19260:739;;;;19403:590;;;;;;;;;;;;;;19260:739;:::o;7292:355:0:-;7390:251;;;;;;7292:355::o;7390:251::-;;;;;;;6145:1089;6813:405;;;;;;-1:-1:-1;6813:405:0;;;;6145:1089::o;411:125:4:-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;411:125:4;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;;:::o;:::-;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;:::o;22573:1135:5:-;;;;;;;;;;;;;;24345:15;;24341:63;;24593:14;;:40;;;;22573:1135;24589:117;;411:125:4;;;24720:23:5;24716:91;;24953:4;411:125:4;;;24932:26:5;24928:95;;411:125:4;;;25037:22:5;25033:89;;25136:17;;25132:77;;411:125:4;;;;;;25350:19:5;25346:74;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23392:28:5;;;:::i;:::-;411:125:4;;;23380:40:5;23443:28;;;:::i;:::-;411:125:4;;;23430:41:5;11357:17;411:125:4;;;;25769:33:5;25793:9;25769:21;:33;:::i;:::-;411:125:4;;;;;;;;26092:23:5;411:125:4;;;;;;11357:17:5;25793:9;26135:22;26131:85;;411:125:4;23540:44:5;411:125:4;;;;11357:17:5;411:125:4;;;;26088:387:5;411:125:4;;;;;;26661:24:5;;;26688:21;;26661:86;411:125:4;;;;23540:44:5;;;:::i;:::-;411:125:4;;;11357:17:5;34926:16;;;;;24359:1;23945:82;;;34919:1569;34962:13;34958:834;;36000:21;411:125:4;;;11357:17:5;36000:21;;;:::i;:::-;411:125:4;;;11357:17:5;36047:9;;35989:68;24359:1;411:125:4;;;;;;;;;11357:17:5;411:125:4;;;;;;;;;;;11357:17:5;49463:14;411:125:4;49463:14:5;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;49543:1164;;;;;;;411:125:4;49543:1164:5;411:125:4;49543:1164:5;;49500:33;49543:1164;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24953:4;;49543:1164;;;;;34919:1569;36071:102;;411:125:4;;;;;36187:143:5;;34919:1569;24359:1;36413:28;411:125:4;;;36413:9:5;411:125:4;;;11357:17:5;36413:28;;:::i;:::-;411:125:4;;;;37057:9:5;411:125:4;;;37104:10:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;24359:1:5;411:125:4;;;;11357:17:5;411:125:4;;;;24359:1:5;37291:9;;;;;;34919:1569;;;;;;37276:13;37337:10;;411:125:4;37337:10:5;;;:::i;:::-;11357:17;37365:14;;;;37361:349;;37276:13;411:125:4;;;;;37276:13:5;;37361:349;37413:35;37431:9;411:125:4;37431:9:5;;;;:::i;:::-;:16;411:125:4;37413:35:5;;:::i;:::-;37493:11;37470:38;37493:11;;;;;:::i;:::-;11357:17;37470:38;;;:::i;:::-;37466:230;;37361:349;;;;;;;37466:230;411:125:4;;;;;;;;37627:11:5;;;;:::i;:::-;11357:17;411:125:4;;;;;;;;;37466:230:5;;;;36187:143;411:125:4;;;11357:17:5;36264:28;:21;;;;;:::i;:::-;:28;:::i;:::-;36294:20;36228:87;411:125:4;36294:20:5;;:::i;:::-;411:125:4;;;;;;;;;;;;;;;;;:::i;:::-;36228:87:5;;;36187:143;;36071:102;411:125:4;;;;;;;;;;;;34919:1569:5;411:125:4;;;;;;41891:24:5;411:125:4;;;41959:11:5;411:125:4;;;;;;;;;11357:17:5;41959:11;;:::i;:::-;411:125:4;;;;42072:187:5;;41887:175;42288:21;;;;;:36;:21;411:125:4;;;11357:17:5;42288:36;;:::i;:::-;42338:12;42334:79;;41887:175;411:125:4;;;;;42427:23:5;42423:243;;41887:175;411:125:4;;;;;11357:17:5;411:125:4;;11357:17:5;22573:1135;:::o;42423:243::-;42487:34;:56;24953:4;;42487:34;;:::i;:::-;411:125:4;;;11357:17:5;42487:56;;:::i;:::-;42561:14;42557:99;42423:243;42557:99;42630:10;411:125:4;;;;;;;;;;;42630:10:5;;:::i;:::-;42557:99;42423:243;;42334:79;42393:8;411:125:4;;;;;;;42393:8:5;:::i;:::-;42334:79;;;42072:187;42109:139;411:125:4;;;;42154:28:5;:21;411:125:4;;;;;11357:17:5;42154:21;;;;:::i;:28::-;411:125:4;;;;11357:17:5;411:125:4;;;;;11357:17:5;411:125:4;;11357:17:5;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24359:1:5;411:125:4;;;;;;;;;;;;42109:139:5;;;;42072:187;;;;;;;41887:175;42039:11;411:125:4;;;;;;;;;;11357:17:5;42039:11;;:::i;:::-;41887:175;;49543:1164;;;411:125:4;24359:1:5;49543:1164;;24359:1;49543:1164;;;;34958:834;411:125:4;;;;;;11357:17:5;35288:30;;;35284:167;;411:125:4;11357:17:5;411:125:4;;;11357:17:5;35612:26;35608:97;;411:125:4;;;;11357:17:5;411:125:4;;11357:17:5;35729:48;;24359:1;35729:48;49543:1164;411:125:4;49543:1164:5;411:125:4;49543:1164:5;24359:1;35729:48;35608:97;35669:17;24359:1;35669:17;49543:1164;24359:1;35669:17;35284:167;35400:1;;;;;;;;;;:::i;:::-;34919:1569;;23945:82;411:125:4;11357:17:5;411:125:4;;;11357:17:5;23966:26;;:60;;23945:82;23966:60;411:125:4;;;;11357:17:5;411:125:4;;;11357:17:5;-1:-1:-1;23996:30:5;23945:82;;34926:16;;;;;;;;;;26661:86;26712:35;24953:4;;26712:35;;:::i;:::-;26661:86;;26131:85;26184:17;24359:1;26184:17;;24359:1;26184:17;26088:387;26310:34;24953:4;;26310:34;;:::i;:::-;411:125:4;;;;;;;;;24359:1:5;9254:988:1;;411:125:4;;;;11357:17:5;9254:988:1;411:125:4;9254:988:1;;411:125:4;9254:988:1;24953:4:5;411:125:4;9254:988:1;26385:10:5;411:125:4;9254:988:1;;;;;;;;;;;24359:1:5;9254:988:1;;;;;;;23540:44:5;9254:988:1;;;24359:1:5;411:125:4;9254:988:1;411:125:4;9254:988:1;25793:9:5;411:125:4;;;;26088:387:5;;9254:988:1;;24359:1:5;9254:988:1;;;;25346:74:5;25392:17;24359:1;25392:17;;24359:1;25392:17;25132:77;25176:22;24359:1;25176:22;;24359:1;25176:22;25033:89;25082:29;24359:1;25082:29;;24359:1;25082:29;24928:95;24981:31;24359:1;24981:31;24953:4;24981:31;411:125:4;;24359:1:5;24981:31;24589:117;24656:39;;;24359:1;24656:39;;411:125:4;;;;24359:1:5;24656:39;24593:40;24611:22;;;;24593:40;;24341:63;24383:10;24359:1;24383:10;;24359:1;24383:10;13466:939:1;13593:806;;;13466:939;13593:806;13466:939;;;13593:806;;;;;;;;;;;;;;;;;;;;;;;13466:939::o;13593:806::-;;;;;;;4031:342;4146:221;4031:342;;;4146:221;;;;;;;4031:342::o;4146:221::-;;;;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;411:125:4;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;27929:5853:5:-;;;;;411:125:4;28141:10:5;;;411:125:4;;28184:14:5;;;11357:17;28232:15;;;;11357:17;28275:12;;;;411:125:4;;;28303:16:5;24359:1;28321:6;;;;;;33756:14;;;;;;;;;411:125:4;27929:5853:5:o;28303:16::-;28367:9;;;;;:::i;:::-;28184:14;28544;;411:125:4;28544:19:5;28540:88;;28967:4;411:125:4;28943:12:5;;;:::i;:::-;411:125:4;28943:29:5;28939:107;;29155:12;;;411:125:4;29185:25:5;11647:9;29185:25;;;29181:97;;24359:1;29320:12;24359:1;29346:14;;24359:1;29374:16;24359:1;29404:23;28141:10;29446:11;;411:125:4;29446:27:5;;;29442:2678;29446:27;;;411:125:4;;28141:10:5;411:125:4;29724:28:5;29701:52;;;;;;;;;;;:::i;:::-;29442:2678;;32134:248;;29442:2678;32396:1280;;;;29442:2678;411:125:4;;;;;;;28303:16:5;;32396:1280;32427:9;;32466:24;32427:9;32466:10;32427:9;;:21;:9;;32742:22;32427:9;;;:21;:::i;:::-;411:125:4;32466:10:5;;:24;:::i;:::-;411:125:4;32742:22:5;;:::i;:::-;32786:45;;;;;32396:1280;32782:231;;32396:1280;33456:206;;;;32396:1280;;;;;;33456:206;33493:11;;;411:125:4;;;33571:14:5;;;;411:125:4;;;;-1:-1:-1;;;;;;;33637:7:5:o;32782:231::-;32855:12;;;;411:125:4;32898:9:5;;;411:125:4;32935:9:5;;;411:125:4;32977:13:5;;;;411:125:4;32782:231:5;;;;32786:45;32799:32;;;;;;;:::i;:::-;32786:45;;32134:248;32168:200;;;;32231:12;;411:125:4;32231:12:5;;:::i;:::-;411:125:4;32208:44:5;28141:10;411:125:4;;;;;;;;;;32208:44:5;32168:200;32134:248;;;;32168:200;32324:12;411:125:4;;32324:12:5;32304:45;32324:12;;:::i;:::-;411:125:4;;28141:10:5;411:125:4;;;;;;;28141:10:5;411:125:4;;;;28141:10:5;411:125:4;;;;:::i;:::-;32304:45:5;;;32168:200;;29442:2678;29778:22;;:42;;;;29442:2678;-1:-1:-1;29774:2346:5;;;411:125:4;28141:10:5;411:125:4;30175:28:5;30152:52;;;;;;;;;;;:::i;:::-;29774:2346;29442:2678;;29774:2346;30477:9;;;;;;;;31319:23;24359:1;411:125:4;;;;;;;;;31453:11:5;;;;;;31449:383;;29774:2346;31893:43;;;;;:::i;:::-;31850:86;;;;;;32078:9;;411:125:4;;29774:2346:5;29442:2678;;31449:383;31488:30;31893:43;31488:30;31544:12;;;;11357:17;31544:28;;31540:274;;31449:383;;;;;31540:274;31621:26;31629:9;;;;11357:17;31621:26;:::i;:::-;31677:28;;;31673:119;;31540:274;;;;31673:119;31737:28;;31673:119;;;29778:42;29804:16;;;;29778:42;;;29181:97;29237:26;;;24359:1;29237:26;;411:125:4;;;;24359:1:5;29237:26;28939:107;29018:12;411:125:4;29018:12:5;;:::i;:::-;28999:32;24359:1;28999:32;411:125:4;28999:32:5;411:125:4;;24359:1:5;28999:32;28540:88;28590:23;24359:1;28590:23;;24359:1;28590:23;27929:5853;;;;;411:125:4;28141:10:5;;;411:125:4;;28184:14:5;;;11357:17;28232:15;;;11357:17;28275:12;;;;411:125:4;;;28303:16:5;28321:6;;;;;;33756:14;;;;;;;;;411:125:4;27929:5853:5:o;28303:16::-;28367:9;;;;;:::i;:::-;28184:14;28544;;411:125:4;28544:19:5;28540:88;;28967:4;411:125:4;28943:12:5;;;:::i;:::-;411:125:4;28943:29:5;28939:107;;29155:12;;;411:125:4;29185:25:5;11647:9;29185:25;;;29181:97;;-1:-1:-1;29320:12:5;-1:-1:-1;29346:14:5;;-1:-1:-1;29374:16:5;-1:-1:-1;29404:23:5;28141:10;29446:11;;411:125:4;29446:27:5;;;29442:2678;29446:27;;;411:125:4;;28141:10:5;411:125:4;29724:28:5;29701:52;;;;;;;;;;;:::i;:::-;29442:2678;;32134:248;;29442:2678;32396:1280;;;;29442:2678;411:125:4;;;;;;;28303:16:5;;32396:1280;32427:9;;32466:24;32427:9;32466:10;32427:9;;:21;:9;;32742:22;32427:9;;;:21;:::i;32742:22::-;32786:45;;;;;32396:1280;32782:231;;32396:1280;33456:206;;;;32396:1280;;;;;;32782:231;32855:12;;;;411:125:4;32898:9:5;;;411:125:4;32935:9:5;;;411:125:4;32977:13:5;;;;411:125:4;32782:231:5;;;;32786:45;32799:32;;;;;;;:::i;:::-;32786:45;;32134:248;32168:200;;;;32231:12;;411:125:4;32231:12:5;;:::i;:::-;411:125:4;32208:44:5;28141:10;411:125:4;;;;;;;;;;32208:44:5;32168:200;32134:248;;;;32168:200;32324:12;411:125:4;;32324:12:5;32304:45;32324:12;;:::i;411:125:4:-;32304:45:5;;;32168:200;;29442:2678;29778:22;;:42;;;;29442:2678;-1:-1:-1;29774:2346:5;;;411:125:4;28141:10:5;411:125:4;30175:28:5;30152:52;;;;;;;;;;;:::i;:::-;29774:2346;29442:2678;;29774:2346;30477:9;;;;;;;;;31319:23;31893:43;;;;;;:::i;:::-;31850:86;;;;;;32078:9;;411:125:4;;29774:2346:5;29442:2678;;29778:42;29804:16;;;;29778:42;;;41044:459;41135:11;;41131:52;;411:125:4;41196:41:5;;41192:96;;11647:9;411:125:4;;;;;41436:16:5;11647:9;411:125:4;;;;;;;;41456:21:5;;411:125:4;41044:459:5:o;41456:29::-;41484:1;411:125:4;;41044:459:5:o;411:125:4:-;;;;;;;;;;41192:96:5;41253:24;;41202:17;41253:24;:::o;41131:52::-;41162:10;;;:::o;51998:2928::-;;;;411:125:4;;;;;;52568:13:5;;;;;:::i;:::-;52595:21;;;52591:72;;51998:2928;411:125:4;;;52677:21:5;;;;;:67;;51998:2928;52673:708;;-1:-1:-1;411:125:4;;;;;49329:10:5;52568:13;49329:10;;11357:17;49415:18;411:125:4;49368:10:5;;;411:125:4;;49415:18:5;;11357:17;49463:14;;;;411:125:4;;;;;;;;;;;;;;;;;;;;;;52568:13:5;411:125:4;;;;;;;;-1:-1:-1;49543:1164:5;;;;;;;49368:10;49543:1164;;49500:33;49543:1164;;53715:4;49543:1164;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;411:125:4;49543:1164:5;53741:14;;411:125:4;49543:1164:5;;;;;51998:2928;53675:81;;53766:19;;53800:10;53796:676;;;;51998:2928;54482:438;;51998:2928;;;:::o;54482:438::-;54786:49;411:125:4;54786:49:5;;54482:438;54782:128;;51998:2928;;:::o;54782:128::-;54855:40;;;:::i;54786:49::-;54801:34;;;;;:::i;:::-;54800:35;54786:49;;53796:676;49543:1164;54081:288;;;;53796:676;54386:8;53796:676;54382:80;54427:20;;;;:::i;:::-;54382:80;53796:676;;54081:288;;;;;49543:1164;-1:-1:-1;54081:288:5;;;-1:-1:-1;54081:288:5;;;;;49543:1164;54081:288;;;;;;49543:1164;;52568:13;-1:-1:-1;49543:1164:5;;-1:-1:-1;49543:1164:5;;;52673:708;53122:29;;;;;;;;;;:::i;:::-;;411:125:4;;53317:52:5;53340:28;52568:13;53317:52;;;;;;;;;;:::i;:::-;-1:-1:-1;53292:78:5;-1:-1:-1;53292:78:5;-1:-1:-1;53292:78:5;;:::o;52677:67::-;52733:10;52703:41;52568:13;52733:10;;11357:17;52703:41;;;:::i;:::-;52702:42;52677:67;;52591:72;-1:-1:-1;;;52591:72:5;;39713:350;;39806:11;;39802:55;;11647:9;411:125:4;11647:9:5;411:125:4;;;;;;;;;;;39713:350:5;:::o;39802:55::-;39833:13;;:::o;38347:812::-;;;;;11357:17;38472:13;;;11357:17;38472:26;38468:68;;38571:14;;;11357:17;38561:24;;;;;38617:12;;;11357:17;38617:30;;;;38661:26;;38657:72;;38738:337;;;39097:9;;;;;11357:17;39091:15;;;:61;;;;;38347:812;39084:68;;;;38347:812;:::o;39091:61::-;39111:16;;-1:-1:-1;39111:16:5;;:40;;39091:61;;;;;;;;;39111:40;39142:9;;11357:17;-1:-1:-1;;;39111:40:5;;;;38738:337;38991:21;;;;-1:-1:-1;38991:21:5;:73;;;;38984:80;;;;;:::o;38657:72::-;38703:15;;;;;;;;:::o;38468:68::-;38514:11;;;;38521:4;38514:11;:::o;59070:488::-;59157:395;;;;;;;59070:488;59157:395;;;;;;;;;;;;;;;;;;;;59070:488::o;59157:395::-;;;-1:-1:-1;59157:395:5;;56883:270;;;56989:32;;;;;:::i;:::-;56985:74;;57069:27;;;57114:32;57069:27;;:::i;:::-;;57114:32;:::i;:::-;56883:270;:::o;56985:74::-;57037:11;;;57044:4;57037:11;:::o;57715:958::-;58335:332;;52228:9;57715:958;;58335:332;57715:958;58335:332;;;;;;;;;;;52228:9;58335:332;;;;;;;52228:9;58335:332;;57715:958::o;:::-;58335:332;;;57715:958;58335:332;57715:958;;;58335:332;;;;;;;;;;;;;;;;;;;;;57715:958::o","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"callRoute()","signatureHash4":"0x068dcae7","signatureHash32":"0x068dcae7f322748279c1c9bd5363bb7ac1c660a1daa8851b17e7b1ed5f0d1765"},{"signature":"cancelOwnershipHandover()","signatureHash4":"0x54d1f13d","signatureHash32":"0x54d1f13d76f000aa202485e9c4b750a3fb26985ca34157c621201e1375bcbfac"},{"signature":"completeOwnershipHandover(address)","signatureHash4":"0xf04e283e","signatureHash32":"0xf04e283ea4b43821701876734697fc3e4a42281d51fee656e5c166b741e6afde"},{"signature":"FEE_DENOMINATOR()","signatureHash4":"0xd73792a9","signatureHash32":"0xd73792a93ce338acd218936051a4a2ff30933dda63de264b6d0cbe7f2cda205f"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownershipHandoverExpiresAt(address)","signatureHash4":"0xfee81cf4","signatureHash32":"0xfee81cf4fcd7f51611a3bf33478e3ef123da30b6dfa31a0b2a6d1192ef3c7e02"},{"signature":"race(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],bool,bytes)","signatureHash4":"0xdbd33919","signatureHash32":"0xdbd33919fb817b33b40579354ad3082665e4b398d63d419341ba1e67a7f25c85"},{"signature":"raceWithBackups(address,uint256,address,uint256,address,address,(address,address,uint256,uint256,uint256,bytes)[],uint256,bool,bytes)","signatureHash4":"0xbda3361c","signatureHash32":"0xbda3361c29354eb8bdd45a94563ae633fa4696c29d3a43256004fb864ed05b01"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"requestOwnershipHandover()","signatureHash4":"0x25692962","signatureHash32":"0x25692962a9adba4272ff0251e0e6793c55bbf553e4476049416aa620e8960301"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"},{"signature":"withdraw(address,address)","signatureHash4":"0xf940e385","signatureHash32":"0xf940e3851549e5c2062f065152e2151c57f5902a4d0de0f053e7f80205e4aabf"}],"event":[{"signature":"OwnershipHandoverCanceled(address)","signatureHash4":"0xfa7b8eab","signatureHash32":"0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92"},{"signature":"OwnershipHandoverRequested(address)","signatureHash4":"0xdbf36a10","signatureHash32":"0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"RouteExecutionFailed(uint256,address,bytes)","signatureHash4":"0x5f2283a2","signatureHash32":"0x5f2283a2b336dc5a06b5e101c3f9b1a23015ea989117f186b2612cdcb56c560e"},{"signature":"RouteRaceWon(uint256,address,uint256,uint256,uint256,bytes)","signatureHash4":"0x7ea83e2f","signatureHash32":"0x7ea83e2f986aa67ac44921ee3b35f1c36885cd0b3170986aaee1033a4f6ed6a5"},{"signature":"RouteTrialFailed(uint256,address,bytes)","signatureHash4":"0x94c0f518","signatureHash32":"0x94c0f5184378c50232ed4384249984a18c121cf41a9cb2d55b2c1c61375a4011"},{"signature":"RouteTrialSucceeded(uint256,address,uint256)","signatureHash4":"0xb202ec83","signatureHash32":"0xb202ec83aa221eb19af3b64e325e0f5acfa21a8993dc9014656df95cedb8f3db"}],"error":[{"signature":"AllRoutesFailed()","signatureHash4":"0xb1895a8f","signatureHash32":"0xb1895a8f549f12b48a67d4df9dab0fdb7f41ab7ca4b4a6425bb511cbbec38d10"},{"signature":"AlreadyInitialized()","signatureHash4":"0x0dc149f0","signatureHash32":"0x0dc149f07762891dbcea3fe72770f3d63a1863fc54b2f084e8c59ec476996927"},{"signature":"ExcessiveRouteValue()","signatureHash4":"0xdade4665","signatureHash32":"0xdade46654f5261789cbc9289f495996a3d08d9a0e589e7f2cbae4304f6b44fa5"},{"signature":"IdenticalTokens()","signatureHash4":"0x5c6d7b73","signatureHash32":"0x5c6d7b735b70fc42edb49bd044775143a44136daa9b413ef28d5a01e62bdd293"},{"signature":"InsufficientOutput(uint256,uint256)","signatureHash4":"0x2c19b8b8","signatureHash32":"0x2c19b8b87dc30ba95595ffd66c13e323be53c04224764b08e36f6411939cc30e"},{"signature":"InvalidMainCount(uint256,uint256)","signatureHash4":"0xc679538f","signatureHash32":"0xc679538f5334283edc12df0ca3d5ecadc9429862bd0b9f4d00c6f46b13bb980e"},{"signature":"InvalidMsgValue()","signatureHash4":"0x1841b4e1","signatureHash32":"0x1841b4e1b5bc2b6ee2d929f61c1a6d695028c1b47aa99b13e72b417bfaebc3cd"},{"signature":"InvalidRecipient(address)","signatureHash4":"0x17858bbe","signatureHash32":"0x17858bbe33f2abed3758965a9f02dee0a7e83a84b7b813e2a23810c33c0858ea"},{"signature":"InvalidRouteFee(uint256,uint256)","signatureHash4":"0xe31b2b11","signatureHash32":"0xe31b2b110a3b0af4b7d3f440f5c3ebe93ee0602d1b25fbd0922f1216e6a54ba6"},{"signature":"InvalidRouteTarget(address)","signatureHash4":"0xc3e8aafc","signatureHash32":"0xc3e8aafc7f3856bab639e0bbb1ad24e7f28861ae9fe51d165ba5ec2f7eec77ad"},{"signature":"MinAmountOutRequired()","signatureHash4":"0xfbabc0db","signatureHash32":"0xfbabc0db9fa5a7de66379b2721deca0a61d6798996ee23e4c1efb3050a563bab"},{"signature":"NewOwnerIsZeroAddress()","signatureHash4":"0x7448fbae","signatureHash32":"0x7448fbae245b5163a637f61fac94c5376c3e155928452ce47ee52d8c1b99587a"},{"signature":"NoHandoverRequest()","signatureHash4":"0x6f5e8818","signatureHash32":"0x6f5e8818469c73d5be4a0d17c371cde64695907022629c1d064c895f98d466a6"},{"signature":"NoRoutes()","signatureHash4":"0xc7678ee6","signatureHash32":"0xc7678ee6223977af55d7a44a7e1c0e40c9db2505c99fa18478da405ff82bd39b"},{"signature":"OnlySelf()","signatureHash4":"0x14d4a4e8","signatureHash32":"0x14d4a4e8a5140da60b7a280478fb427da973ca582a83cf5dbad8c5f2abee9ba4"},{"signature":"RecipientCannotBeZeroAddress()","signatureHash4":"0xd8707052","signatureHash32":"0xd87070525216640f0088557d8ae6b100948c1128c501455e84477460eaace49a"},{"signature":"Reentrancy()","signatureHash4":"0xab143c06","signatureHash32":"0xab143c06c9772d69bbbc9f2fe74acd02f810e93b099f3d1dac8448ac9ae35991"},{"signature":"RefundToCannotBeZeroAddress()","signatureHash4":"0xfc62e08f","signatureHash32":"0xfc62e08fdef17fc4f4955cf395867e29cd32c7ba567943d418ec9ceca6876f7f"},{"signature":"RouteApprovalFailed()","signatureHash4":"0xa7dedec1","signatureHash32":"0xa7dedec1a1cfc272c88f58e03b326ca3e7ad8ba31f62f4762ef07364ead6f06b"},{"signature":"RouteGasLimitRequired()","signatureHash4":"0xfc370e7d","signatureHash32":"0xfc370e7dac7721c5ad6a0a6e98333dac3b1d8a77d8509acebfd3cacd0cfbe6bc"},{"signature":"TrialResult(uint256)","signatureHash4":"0x1fa0573e","signatureHash32":"0x1fa0573ed1e41aba66f6c9a8cbc6f3cd0fd9b2a744d9dc1038961ffb09c2bafc"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"},{"signature":"ValueOnNativeOutput()","signatureHash4":"0xf247f392","signatureHash32":"0xf247f392f7233a2714f4836f9c269157f836d9f21f70772927f07ec94997c016"},{"signature":"WinnerUnderperformed(uint256,uint256)","signatureHash4":"0x5cebc26b","signatureHash32":"0x5cebc26b7ffcefb5061e2995bb1c63c08589e585438ae4a6b24f0c04f84158d9"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x195627f03fE2668d65c763CD39eeC45B1D76c8ee"}