{"matchId":"43854757","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2026-08-20T02:21:01Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1898:10149:3:-:0;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;5710:347:0;;;-1:-1:-1;;5710:347:0;;;-1:-1:-1;5710:347:0;-1:-1:-1;;5710:347:0;1898:10149:3;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;1898:10149:3;;11679:20;;:42;;;;-1:-1:-1;11679:58:3;;;;-1:-1:-1;11675:117:3;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;5710:347:0;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;11872:36;1898:10149;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;11918:28;1898:10149;11826:10;1898:10149;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;;;11826:10;1898:10149;;;;;11918:28;1898:10149;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;1898:10149:3;;;11962:76;;;;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11918:28;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;11826:10;1898:10149;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;11918:28;1898:10149;;;;;;;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11826:10;1898:10149;;;;;;;;11918:28;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;11826:10;1898:10149;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;11675:117;11760:21;;;-1:-1:-1;11760:21:3;;-1:-1:-1;11760:21:3;11679:58;11725:12;;;11679:58;;:42;-1:-1:-1;;;;;;1898:10149:3;;11703:18;11679:42;;1898:10149;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220ccec4bf8dadded11c3c4681da7b38147c5b052f45398363abae5fbe6f1abdf1064736f6c634300081e0033","offset":8220}},"transformations":[{"type":"insert","offset":8305,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000047f606fd5b2baa5f5c6c4ab8958e45cb6b054b7000000000000000000000000d34a99bc0f67ae1bbd63c660e6d0b0dd03e263b7000000000000000000000000d34a99bc0f67ae1bbd63c660e6d0b0dd03e263b700000000000000000000000000000000000000000000000000000000000075e8000000000000000000000000f9d7cbf5bef2f5c9ba93a70f31ddca6457716793"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"1898:10149:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;11885:237:0;;;1898:10149:3;11885:237:0;1898:10149:3;11885:237:0;;;;1898:10149:3;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;:::-;1898:10149:3;8479:183:0;;1898:10149:3;8479:183:0;1898:10149:3;8479:183:0;;1898:10149:3;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;1898:10149:3;10506:526:0;1898:10149:3;10506:526:0;;;;;;;;;1898:10149:3;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;1898:10149:3;10506:526:0;1898:10149:3;10506:526:0;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;11151:6;1898:10149;;:::i;:::-;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;11151:6;;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;8240:32;;:::i;:::-;1898:10149;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;3088:31;1898:10149;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;4279:40;1898:10149;;;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;;;4279:40;1898:10149;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;2091:42;1898:10149;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;3899:69;1898:10149;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;;;;3923:3;1898:10149;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;3899:69;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;-1:-1:-1;;11523:61:0;1898:10149:3;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;4065:69;1898:10149;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;4102:16;1898:10149;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;3062:20;1898:10149;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;2181:5;1898:10149;;;;;;-1:-1:-1;;1898:10149:3;;;;12478:70:0;;:::i;:::-;1898:10149:3;6813:405:0;;;;;;;1898:10149:3;-1:-1:-1;;6813:405:0;1898:10149:3;;;;-1:-1:-1;;1898:10149:3;;;;9831:339:0;;;;1898:10149:3;9831:339:0;1898:10149:3;9831:339:0;;;;;;1898:10149:3;9831:339:0;;1898:10149:3;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;8411:27;-1:-1:-1;;8411:27:3;:::i;:::-;1898:10149;;;;;;;;;;;8391:55;;;1898:10149;8391:55;;1898:10149;;;;;;:::i;:::-;;;;;;8391:55;;;;;;;;1898:10149;8391:55;;;1898:10149;;;;;;;;;;;;;;;;;;;;;;8391:55;;1898:10149;8391:55;1898:10149;8391:55;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;;;;:::i;:::-;8391:55;;;;;;;;1898:10149;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;1575:245:1;;;;;;;;;10445:10:3;;9021:22;9017:49;;1898:10149;9106:27;-1:-1:-1;;9106:27:3;:::i;:::-;1898:10149;;;;;9174:3;1898:10149;;;;;;;;9169:37;;1898:10149;;9169:37;;1898:10149;;;;;;;;;;:::i;:::-;;;;;;9169:37;;;;;;;;;;1898:10149;9169:37;;;1898:10149;;;;9220:9;;:25;9216:86;;1898:10149;;;;;;;;;9424:18;;1898:10149;9424:18;;1898:10149;9424:18;;;:::i;:::-;1898:10149;;;9480:63;1898:10149;;;;;;;9480:63;;1898:10149;;9480:63;;1898:10149;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9480:63;;;;;;;;;;1898:10149;;;9480:63;;;1898:10149;9553:53;;;;;:::i;:::-;1898:10149;;;;;9680:12;;1898:10149;;9622:151;1898:10149;;;;9719:27;;1898:10149;;;;;;;;;;;;;;;;;9622:151;1898:10149;9220:9;;1898:10149;9220:9;;1898:10149;;;;9220:9;9841:12;9837:73;;1898:10149;1883:75:1;;;1575:245;1883:75;1898:10149:3;;;;;;;;:::i;9837:73::-;9902:7;;;:::i;:::-;9837:73;;;;1898:10149;;;;;;;;;;;;9480:63;;;;;;;;;;;;;;;;:::i;:::-;;;1898:10149;;;9480:63;1898:10149;;;;;-1:-1:-1;1898:10149:3;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9553:53;1898:10149;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;9480:63;;;;;;;;;;9216:86;9254:48;;;1898:10149;9254:48;1898:10149;;9220:9;1898:10149;;;;9254:48;9169:37;;;1898:10149;9169:37;1898:10149;9169:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;9169:37;;;;;;;;9017:49;10445:10;;9017:49;;1575:245:1;;1898:10149:3;1575:245:1;1898:10149:3;1575:245:1;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;1990:42;1898:10149;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;11012:6;1898:10149;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;11012:6;:::i;1898:10149::-;;;-1:-1:-1;;1898:10149:3;;;;9239:383:0;;;;1898:10149:3;9239:383:0;7972:9;9132:15;1898:10149:3;9239:383:0;;;;;;1898:10149:3;9239:383:0;;1898:10149:3;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;;10113:47;10149:10;1898:10149;;10113:47;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;8411:27;1898:10149;;8411:27;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;3728:73;1898:10149;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;:::i;:::-;3728:73;;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;12478:70:0;;:::i;:::-;-1:-1:-1;;;;;1898:10149:3;;;10697:16;;10693:53;;10760:11;;10756:45;;10853:6;;10875:22;10853:6;1898:10149;10853:6;;:::i;:::-;1898:10149;;;;;10875:22;1898:10149;10756:45;10780:21;;;1898:10149;10780:21;1898:10149;;10780:21;10693:53;10722:24;;;1898:10149;10722:24;1898:10149;;10722:24;1898:10149;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;1898:10149:3;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;-1:-1:-1;1898:10149:3;3955:12;1898:10149;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;3955:12:3;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4691:1929;;1898:10149;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;;;;;;;4799:16;1898:10149;;4799:30;;;4795:67;;4876:14;;4872:48;;4951:14;;:::i;:::-;4992:21;;;;;;:45;;4975:62;5051:11;;5047:45;;5147:6;1898:10149;;;;;;;:::i;:::-;;;;;;;;;5115:255;;1898:10149;;5115:255;;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;-1:-1:-1;1898:10149:3;;;;:::i;:::-;;5115:255;;1898:10149;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;5103:267;5766:23;;;:::i;:::-;5803:36;;;;;4992:45;5799:68;;;4992:45;5881:11;;5877:45;;1898:10149;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;6003:29;;;;;;1898:10149;;;;;;:::i;:::-;6003:29;;-1:-1:-1;;;;;1898:10149:3;6003:29;;;;;;;-1:-1:-1;6003:29:3;;;4992:45;1898:10149;;;6136:25;:58;;;;4992:45;6132:92;;1898:10149;;;;6238:40;;;;6234:109;;1898:10149;;6003:29;1898:10149;;;6405:34;;;6401:102;;1898:10149;;;;;;6589:24;1898:10149;;;4691:1929::o;6401:102::-;6448:55;;;-1:-1:-1;6448:55:3;6003:29;1898:10149;;;;-1:-1:-1;6448:55:3;6234:109;6287:56;;;-1:-1:-1;6287:56:3;6003:29;1898:10149;;;;-1:-1:-1;6287:56:3;6136:58;6165:24;;;;1898:10149;6165:29;6136:58;;6003:29;;;;;;;-1:-1:-1;6003:29:3;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;5799:68;5850:17;;;1898:10149;;-1:-1:-1;5799:68:3;;5803:36;5822:17;;;;;1898:10149;-1:-1:-1;5803:36:3;;;4992:45;;;;;4332:125;4419:5;1898:10149;;;-1:-1:-1;;;4403:47:3;;4444:4;4403:47;;;1898:10149;;;;;;4403:47;;1898:10149;;-1:-1:-1;;;;;1898:10149:3;4403:47;;;;;;;4419:5;4403:47;;;4396:54;4332:125;:::o;4403:47::-;;;1898:10149;4403:47;;1898:10149;4403:47;;;;;;1898:10149;4403:47;;;:::i;:::-;;;1898:10149;;;;;4332:125;:::o;4403:47::-;;;-1:-1:-1;4403:47:3;;1898:10149;;;;;;;;;;;;;;;;;:::i;7443:552::-;1898:10149;;-1:-1:-1;;;7617:32:3;;-1:-1:-1;;7617:32:3;;;1898:10149;10426:17;1898:10149;7617:32;1898:10149;7617:4;:32;;-1:-1:-1;;7617:32:3;;;7443:552;-1:-1:-1;7613:376:3;;7962:16;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;:::o;7613:376::-;1898:10149;;;;;-1:-1:-1;;;7705:37:3;;7617:32;7705:37;;1898:10149;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;:::i;:::-;-1:-1:-1;7617:32:3;1898:10149;;;7705:37;;;;-1:-1:-1;;7705:37:3;;;7613:376;-1:-1:-1;7701:230:3;;7900:16;;-1:-1:-1;7900:16:3;-1:-1:-1;7900:16:3;-1:-1:-1;7900:16:3;:::o;7701:230::-;1898:10149;7803:18;;1898:10149;7823:21;;;;1898:10149;;;;;7795:65::o;7705:37::-;;;;1898:10149;7705:37;1898:10149;7705:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;7705:37;;;;;;;;;7617:32;;;;;;-1:-1:-1;7617:32:3;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;:::i;:::-;;;;;7617:32;;;;7443:552;1898:10149;;;;;;7617:32;;;;;1898:10149;-1:-1:-1;7617:4:3;:32;:4;;:32;;-1:-1:-1;;7617:32:3;;;-1:-1:-1;7613:376:3;;7962:16;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;:::o;8797:1120::-;;;;1898:10149;;:::i;:::-;;;;:::i;:::-;;1575:245:1;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;9021:22;9017:49;;8797:1120;9106:27;;;:::i;:::-;1898:10149;;;;;9174:3;1898:10149;;;;;;;;9169:37;;1898:10149;9169:37;;;1898:10149;;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;9169:37;;;;;;;;;;-1:-1:-1;9169:37:3;;;8797:1120;1898:10149;;;9220:9;;:25;9216:86;;1898:10149;;;;;;-1:-1:-1;1898:10149:3;;9424:18;;1898:10149;9424:18;;1898:10149;9424:18;;;:::i;:::-;1898:10149;;;9480:63;1898:10149;;;;;;;9480:63;;1898:10149;9169:37;9480:63;;1898:10149;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9480:63;;;;;;;;;;-1:-1:-1;;;9480:63:3;;;8797:1120;9553:53;;;;;:::i;:::-;1898:10149;;;;;9680:12;;1898:10149;;9622:151;1898:10149;;;;9719:27;;1898:10149;;;;;;;;;;;;;;;;;9622:151;1898:10149;9220:9;;1898:10149;9220:9;;1898:10149;;;;9220:9;9841:12;9837:73;;8797:1120;1883:75:1;;;1575:245;1883:75;8973:28:3;8797:1120;:::o;9837:73::-;9902:7;;;:::i;:::-;9837:73;;;;9480:63;;;;;;;;;;;;;;;;:::i;:::-;;;1898:10149;;;9480:63;1898:10149;;;;;-1:-1:-1;1898:10149:3;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9553:53;1898:10149;;;;;;;;;;;;;;;;:::i;:::-;9480:63;;;;;;;;;;9169:37;;;1898:10149;9169:37;1898:10149;9169:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;9169:37;;;;;;;;9017:49;9056:10;;-1:-1:-1;9017:49:3;;7292:355:0;-1:-1:-1;;7390:251:0;;;;;7292:355::o;7390:251::-;;;;;;;6934:721:2;7054:595;;;;;;;;;;;;;;;;6934:721;;:::o;7054:595::-;;;;;;;;;;;;;;;;;6934:721::o;7054:595::-;;;;;;;;;;;11483:562:3;;;;;;-1:-1:-1;;;;;1898:10149:3;;11679:20;;:42;;;;11483:562;11679:58;;;;11483:562;11675:117;;11697:1;1898:10149;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;;1898:10149:3;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;-1:-1:-1;;;1898:10149:3;;;;;11872:36;1898:10149;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;11918:28;1898:10149;;:::i;:::-;;;;;;11483:562;1898:10149;;;;;;;;;;;11962:76;1898:10149;;;;;11697:1;1898:10149;;;;;;11826:10;1898:10149;10426:17;;;1898:10149;11918:28;1898:10149;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11962:76;;;11483:562::o;1898:10149::-;;;;;;;;;;;;;;11918:28;11697:1;1898:10149;-1:-1:-1;;;;;;;;;;;1898:10149:3;11697:1;1898:10149;;;;;;;;11962:76;1898:10149;;;;;;11826:10;1898:10149;;;;;;;;;;;11918:28;1898:10149;;;;;;;10426:17;;1898:10149;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11826:10;1898:10149;;;;;;;;11918:28;11697:1;1898:10149;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;11697:1;1898:10149;;11826:10;1898:10149;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;-1:-1:-1;1898:10149:3;;11675:117;11760:21;;;11697:1;11760:21;;11697:1;11760:21;11679:58;1898:10149;;;;11725:12;11679:58;;:42;-1:-1:-1;;;;;;1898:10149:3;;11703:18;11679:42;;11171:306;-1:-1:-1;;;;;1898:10149:3;;;11171:306;11260:16;;11256:53;;11323:11;;11319:45;;16484:754:2;;;;;;;;11274:1:3;16484:754:2;;11274:1:3;16484:754:2;;;;;;;;11274:1:3;16484:754:2;;;;;;11171:306:3;-1:-1:-1;11274:1:3;16484:754:2;;1898:10149:3;;;;;-1:-1:-1;;;;;1898:10149:3;;11438:32;;16484:754:2;;11438:32:3;11171:306::o;16484:754:2:-;;;;;;;;;;;;;;;11274:1:3;16484:754:2;;;;6626:434:3;1898:10149;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;6805:3;1898:10149;;;;;;;;;;;;6800:29;;1898:10149;6800:29;;;1898:10149;;;;;;:::i;:::-;6800:29;;;;;1898:10149;;;6800:29;;;6626:434;-1:-1:-1;6796:258:3;;7013:30;;1898:10149;7013:30;;;:::o;6796:258::-;6805:3;;-1:-1:-1;6950:31:3;;-1:-1:-1;6950:31:3;:::o;6800:29::-;;;;;;;;;1898:10149;6800:29;;;;;;:::i;:::-;;;;-1:-1:-1;6800:29:3;;;6145:1089:0;1898:10149:3;;;;;6813:405:0;;;;;;-1:-1:-1;6813:405:0;;-1:-1:-1;;6813:405:0;6145:1089::o;20183:1707:2:-;;20318:1566;;-1:-1:-1;20318:1566:2;;;;;-1:-1:-1;20318:1566:2;;-1:-1:-1;20318:1566:2;;;;;;;;-1:-1:-1;20318:1566:2;;;;;;20183:1707;20318:1566;;-1:-1:-1;20318:1566:2;;20183:1707::o;20318:1566::-;;;;;;;;;;;;;;;-1:-1:-1;20318:1566:2;;;;-1:-1:-1;;;20318:1566:2;;;;;-1:-1:-1;20318:1566:2;;;;-1:-1:-1;20318:1566:2;;;-1:-1:-1;20318:1566:2;;;;;;;;;-1:-1:-1;20318:1566:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20318:1566:2;;;;20183:1707;;;20318:1566;;;;;;;;;;;;;;;;;;;;;;;;;;;20183:1707;20318:1566;;;;;;20183:1707::o;20318:1566::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20318:1566:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220ccec4bf8dadded11c3c4681da7b38147c5b052f45398363abae5fbe6f1abdf1064736f6c634300081e0033","offset":7352}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x85b1cdf9a33be65dd912d1d8ddb72643250aff95a01752c78e3f70327e7a9303","blockNumber":"25793167","transactionIndex":"120","deployer":"0x047F606fD5b2BaA5f5C6c4aB8958E45CB6B054B7"},"sources":{"src/BurnExecutor.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {Ownable} from \"solady/auth/Ownable.sol\";\nimport {ReentrancyGuard} from \"solady/utils/ReentrancyGuard.sol\";\nimport {SafeTransferLib} from \"solady/utils/SafeTransferLib.sol\";\n\nstruct SendParam {\n    uint32 dstEid;\n    bytes32 to;\n    uint256 amountLD;\n    uint256 minAmountLD;\n    bytes extraOptions;\n    bytes composeMsg;\n    bytes oftCmd;\n}\n\nstruct MessagingFee {\n    uint256 nativeFee;\n    uint256 lzTokenFee;\n}\n\nstruct OFTLimit {\n    uint256 minAmountLD;\n    uint256 maxAmountLD;\n}\n\nstruct OFTFeeDetail {\n    int256 feeAmountLD;\n    string description;\n}\n\nstruct MessagingReceipt {\n    bytes32 guid;\n    uint64 nonce;\n    MessagingFee fee;\n}\n\nstruct OFTReceipt {\n    uint256 amountSentLD;\n    uint256 amountReceivedLD;\n}\n\ninterface IOFT {\n    function quoteOFT(SendParam calldata sendParam)\n        external\n        view\n        returns (OFTLimit memory limit, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory receipt);\n\n    function quoteSend(SendParam calldata sendParam, bool payInLzToken) external view returns (MessagingFee memory fee);\n\n    function send(SendParam calldata sendParam, MessagingFee calldata fee, address refundAddress)\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt);\n}\n\ninterface IERC20BalanceOf {\n    function balanceOf(address owner) external view returns (uint256);\n}\n\n/// @notice Holds sold tokens until anyone bridges them to the Base burn receiver.\n/// @dev Bridging is permissionless because the only reachable destination is the owner-configured\n/// burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose\n/// where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's\n/// own limits, so a stale or oversized request is clamped instead of reverting.\ncontract BurnExecutor is Ownable, ReentrancyGuard {\n    address public constant IMD_TOKEN = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;\n    address public constant DEFAULT_BASE_BURN_RECEIVER = 0x4b118f0C63d09f09cB35fC6e8024A6c96493EaDA;\n    uint32 public constant BASE_MAINNET_EID = 30184;\n\n    error InvalidBridgeRecipient();\n    error InvalidBridgeAmount();\n    error InvalidBridgeConfig();\n    error InsufficientMessageFee(uint256 required, uint256 provided);\n    error BelowOftMinimum(uint256 amount, uint256 oftMinimum);\n    error BelowMinBridgeAmount(uint256 amount, uint256 minimum);\n\n    event BridgeConfigUpdated(\n        address indexed token, address indexed oft, uint32 indexed dstEid, address baseBurnReceiver, bytes extraOptions\n    );\n    event MinBridgeAmountUpdated(uint256 minBridgeAmount);\n    event TokensBridgedForBurn(\n        address indexed oft, uint32 indexed dstEid, bytes32 indexed to, uint256 amount, uint256 minAmount, bytes32 guid\n    );\n    event TokenRescued(address indexed token, address indexed to, uint256 amount);\n    event ETHRescued(address indexed to, uint256 amount);\n\n    address public token;\n    address public oft;\n    uint32 public dstEid;\n    address public baseBurnReceiver;\n    bytes public extraOptions;\n\n    /// @notice Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor.\n    uint256 public minBridgeAmount;\n\n    constructor(address owner_, address token_, address oft_, uint32 dstEid_, address baseBurnReceiver_) {\n        _initializeOwner(owner_);\n        _setBridgeConfig(token_, oft_, dstEid_, baseBurnReceiver_, \"\");\n    }\n\n    function setBridgeConfig(\n        address token_,\n        address oft_,\n        uint32 dstEid_,\n        address baseBurnReceiver_,\n        bytes calldata extraOptions_\n    ) external onlyOwner {\n        _setBridgeConfig(token_, oft_, dstEid_, baseBurnReceiver_, extraOptions_);\n    }\n\n    function setBaseBurnReceiver(address baseBurnReceiver_) external onlyOwner {\n        _setBridgeConfig(token, oft, dstEid, baseBurnReceiver_, extraOptions);\n    }\n\n    function setExtraOptions(bytes calldata extraOptions_) external onlyOwner {\n        _setBridgeConfig(token, oft, dstEid, baseBurnReceiver, extraOptions_);\n    }\n\n    function setMinBridgeAmount(uint256 minBridgeAmount_) external onlyOwner {\n        minBridgeAmount = minBridgeAmount_;\n        emit MinBridgeAmountUpdated(minBridgeAmount_);\n    }\n\n    function tokenBalance() public view returns (uint256) {\n        return IERC20BalanceOf(token).balanceOf(address(this));\n    }\n\n    /// @notice Resolves `requested` into the exact parameters a bridge call would use right now.\n    /// @dev Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer\n    /// a zero over a revert.\n    function resolveSendParam(uint256 requested) public view returns (SendParam memory sendParam) {\n        if (baseBurnReceiver == address(0)) revert InvalidBridgeRecipient();\n        if (requested == 0) revert InvalidBridgeAmount();\n\n        uint256 available = tokenBalance();\n        uint256 amount = requested < available ? requested : available;\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        sendParam = SendParam({\n            dstEid: dstEid,\n            to: bytes32(uint256(uint160(baseBurnReceiver))),\n            amountLD: 0,\n            minAmountLD: 0,\n            extraOptions: extraOptions,\n            composeMsg: \"\",\n            oftCmd: \"\"\n        });\n\n        // Probe the OFT with a zero amount first. A zero can never trip a cap, a rate limiter, or a\n        // per-message maximum, so it reports the current limits even on OFTs whose quote reverts for\n        // an oversized request. Rate-limited or capped OFTs accept less than the full balance; take\n        // what fits instead of failing.\n        (bool probed, OFTLimit memory limit,) = _tryQuoteOFT(sendParam);\n        if (probed && amount > limit.maxAmountLD) amount = limit.maxAmountLD;\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        sendParam.amountLD = amount;\n        (,, OFTReceipt memory receipt) = IOFT(oft).quoteOFT(sendParam);\n\n        // Shared-decimal dust is stripped by the OFT and stays here for the next batch.\n        if (receipt.amountSentLD == 0 || receipt.amountReceivedLD == 0) revert InvalidBridgeAmount();\n        if (receipt.amountSentLD < limit.minAmountLD) revert BelowOftMinimum(receipt.amountSentLD, limit.minAmountLD);\n\n        uint256 floorAmount = minBridgeAmount;\n        if (receipt.amountSentLD < floorAmount) revert BelowMinBridgeAmount(receipt.amountSentLD, floorAmount);\n\n        sendParam.amountLD = receipt.amountSentLD;\n        sendParam.minAmountLD = receipt.amountReceivedLD;\n    }\n\n    function _tryQuoteOFT(SendParam memory sendParam)\n        internal\n        view\n        returns (bool ok, OFTLimit memory limit, OFTReceipt memory receipt)\n    {\n        try IOFT(oft).quoteOFT(sendParam) returns (\n            OFTLimit memory limit_, OFTFeeDetail[] memory, OFTReceipt memory receipt_\n        ) {\n            return (true, limit_, receipt_);\n        } catch {\n            return (false, limit, receipt);\n        }\n    }\n\n    /// @notice Non-reverting view of what a bridge of `requested` would move and cost.\n    /// @return amountToSend Tokens debited here, already clamped to the balance, OFT limits, and dust.\n    /// @return minAmountToReceive Tokens credited to the Base burn receiver.\n    /// @return nativeFee Wei the call must be funded with. All three are zero when nothing is bridgeable.\n    function previewBridge(uint256 requested)\n        public\n        view\n        returns (uint256 amountToSend, uint256 minAmountToReceive, uint256 nativeFee)\n    {\n        try this.resolveSendParam(requested) returns (SendParam memory sendParam) {\n            try IOFT(oft).quoteSend(sendParam, false) returns (MessagingFee memory fee) {\n                return (sendParam.amountLD, sendParam.minAmountLD, fee.nativeFee);\n            } catch {\n                return (0, 0, 0);\n            }\n        } catch {\n            return (0, 0, 0);\n        }\n    }\n\n    /// @notice Non-reverting preview of bridging everything currently held.\n    function previewBridge()\n        external\n        view\n        returns (uint256 amountToSend, uint256 minAmountToReceive, uint256 nativeFee)\n    {\n        return previewBridge(type(uint256).max);\n    }\n\n    function quoteBridgeFee(uint256 requested) public view returns (MessagingFee memory fee) {\n        return IOFT(oft).quoteSend(resolveSendParam(requested), false);\n    }\n\n    function quoteBridgeFee() external view returns (MessagingFee memory fee) {\n        return quoteBridgeFee(type(uint256).max);\n    }\n\n    /// @notice Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver.\n    /// @dev Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`.\n    function bridgeToBaseBurnReceiver(uint256 requested, address refundTo)\n        public\n        payable\n        nonReentrant\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        if (refundTo == address(0)) refundTo = msg.sender;\n\n        SendParam memory sendParam = resolveSendParam(requested);\n        MessagingFee memory fee = IOFT(oft).quoteSend(sendParam, false);\n        if (msg.value < fee.nativeFee) revert InsufficientMessageFee(fee.nativeFee, msg.value);\n\n        address oft_ = oft;\n        address token_ = token;\n        SafeTransferLib.safeApproveWithRetry(token_, oft_, sendParam.amountLD);\n        (msgReceipt, oftReceipt) = IOFT(oft_).send{value: fee.nativeFee}(sendParam, fee, refundTo);\n        SafeTransferLib.safeApproveWithRetry(token_, oft_, 0);\n\n        emit TokensBridgedForBurn(\n            oft_, sendParam.dstEid, sendParam.to, oftReceipt.amountSentLD, oftReceipt.amountReceivedLD, msgReceipt.guid\n        );\n\n        uint256 surplus = msg.value - fee.nativeFee;\n        if (surplus != 0) SafeTransferLib.forceSafeTransferETH(refundTo, surplus);\n    }\n\n    function bridgeToBaseBurnReceiver(uint256 requested)\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        return bridgeToBaseBurnReceiver(requested, msg.sender);\n    }\n\n    /// @notice Bridges everything currently sendable.\n    function bridgeToBaseBurnReceiver()\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        return bridgeToBaseBurnReceiver(type(uint256).max, msg.sender);\n    }\n\n    /// @notice Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so\n    /// a normal bridge never leaves ETH here.\n    function rescueETH(address to, uint256 amount) external onlyOwner {\n        if (to == address(0)) revert InvalidBridgeRecipient();\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        SafeTransferLib.forceSafeTransferETH(to, amount);\n        emit ETHRescued(to, amount);\n    }\n\n    function rescueToken(address to, uint256 amount) external onlyOwner {\n        _rescueToken(token, to, amount);\n    }\n\n    function rescueToken(address token_, address to, uint256 amount) external onlyOwner {\n        _rescueToken(token_, to, amount);\n    }\n\n    function _rescueToken(address token_, address to, uint256 amount) internal {\n        if (to == address(0)) revert InvalidBridgeRecipient();\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        SafeTransferLib.safeTransfer(token_, to, amount);\n        emit TokenRescued(token_, to, amount);\n    }\n\n    function _setBridgeConfig(\n        address token_,\n        address oft_,\n        uint32 dstEid_,\n        address baseBurnReceiver_,\n        bytes memory extraOptions_\n    ) internal {\n        if (token_ == address(0) || oft_ == address(0) || dstEid_ == 0) {\n            revert InvalidBridgeConfig();\n        }\n\n        token = token_;\n        oft = oft_;\n        dstEid = dstEid_;\n        baseBurnReceiver = baseBurnReceiver_;\n        extraOptions = extraOptions_;\n\n        emit BridgeConfigUpdated(token_, oft_, dstEid_, baseBurnReceiver_, extraOptions_);\n    }\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/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Reentrancy guard mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ReentrancyGuard.sol)\nabstract contract ReentrancyGuard {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Unauthorized reentrant call.\n    error Reentrancy();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Equivalent to: `uint72(bytes9(keccak256(\"_REENTRANCY_GUARD_SLOT\")))`.\n    /// 9 bytes is large enough to avoid collisions with lower slots,\n    /// but not too large to result in excessive bytecode bloat.\n    uint256 private constant _REENTRANCY_GUARD_SLOT = 0x929eee149b4bd21268;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      REENTRANCY GUARD                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Guards a function from reentrancy.\n    modifier nonReentrant() virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {\n                mstore(0x00, 0xab143c06) // `Reentrancy()`.\n                revert(0x1c, 0x04)\n            }\n            sstore(_REENTRANCY_GUARD_SLOT, address())\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(_REENTRANCY_GUARD_SLOT, codesize())\n        }\n    }\n\n    /// @dev Guards a view function from read-only reentrancy.\n    modifier nonReadReentrant() virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {\n                mstore(0x00, 0xab143c06) // `Reentrancy()`.\n                revert(0x1c, 0x04)\n            }\n        }\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.\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 ERC20 `totalSupply` query has failed.\n    error TotalSupplyQueryFailed();\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    /// @dev The Permit2 approve operation has failed.\n    error Permit2ApproveFailed();\n\n    /// @dev The Permit2 lockdown operation has failed.\n    error Permit2LockdownFailed();\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 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    /// @dev The canonical address of the `SELFDESTRUCT` ETH mover.\n    /// See: https://gist.github.com/Vectorized/1cb8ad4cf393b1378e08f23f79bd99fa\n    /// [Etherscan](https://etherscan.io/address/0x00000000000073c48c8055bD43D1A53799176f0D)\n    address internal constant ETH_MOVER = 0x00000000000073c48c8055bD43D1A53799176f0D;\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)) {\n                    revert(codesize(), codesize())\n                } // 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\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) internal returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Force transfers ETH to `to`, without triggering the fallback (if any).\n    /// This method attempts to use a separate contract to send via `SELFDESTRUCT`,\n    /// and upon failure, deploys a minimal vault to accrue the ETH.\n    function safeMoveETH(address to, uint256 amount) internal returns (address vault) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            to := shr(96, shl(96, to)) // Clean upper 96 bits.\n            for { let mover := ETH_MOVER } iszero(eq(to, address())) {} {\n                let selfBalanceBefore := selfbalance()\n                if or(lt(selfBalanceBefore, amount), eq(to, mover)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                if extcodesize(mover) {\n                    let balanceBefore := balance(to) // Check via delta, in case `SELFDESTRUCT` is bricked.\n                    mstore(0x00, to)\n                    pop(call(gas(), mover, amount, 0x00, 0x20, codesize(), 0x00))\n                    // If `address(to).balance >= amount + balanceBefore`, skip vault workflow.\n                    if iszero(lt(balance(to), add(amount, balanceBefore))) { break }\n                    // Just in case `SELFDESTRUCT` is changed to not revert and do nothing.\n                    if lt(selfBalanceBefore, selfbalance()) { invalid() }\n                }\n                let m := mload(0x40)\n                // If the mover is missing or bricked, deploy a minimal vault\n                // that withdraws all ETH to `to` when being called only by `to`.\n                // forgefmt: disable-next-item\n                mstore(add(m, 0x20), 0x33146025575b600160005260206000f35b3d3d3d3d47335af1601a5760003dfd)\n                mstore(m, or(to, shl(160, 0x6035600b3d3960353df3fe73)))\n                // Compute and store the bytecode hash.\n                mstore8(0x00, 0xff) // Write the prefix.\n                mstore(0x35, keccak256(m, 0x40))\n                mstore(0x01, shl(96, address())) // Deployer.\n                mstore(0x15, 0) // Salt.\n                vault := keccak256(0x00, 0x55)\n                pop(call(gas(), vault, amount, codesize(), 0x00, codesize(), 0x00))\n                // The vault returns a single word on success. Failure reverts with empty data.\n                if iszero(returndatasize()) {\n                    if iszero(create2(0, m, 0x40, 0)) { revert(codesize(), codesize()) } // For gas estimation.\n                }\n                mstore(0x40, m) // Restore the free memory pointer.\n                break\n            }\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            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\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 := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                success := lt(or(iszero(extcodesize(token)), returndatasize()), success)\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            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\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                    success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    if iszero(and(eq(mload(0x00), 1), success)) {\n                        // Check the `extcodesize` again just in case the token selfdestructs lol.\n                        if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                            mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                            revert(0x1c, 0x04)\n                        }\n                    }\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 := 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 Performs a `token.balanceOf(account)` check.\n    /// `implemented` denotes whether the `token` does not implement `balanceOf`.\n    /// `amount` is zero if the `token` does not implement `balanceOf`.\n    function checkBalanceOf(address token, address account)\n        internal\n        view\n        returns (bool implemented, uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            implemented := 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            amount := mul(mload(0x20), implemented)\n        }\n    }\n\n    /// @dev Returns the total supply of the `token`.\n    /// Reverts if the token does not exist or does not implement `totalSupply()`.\n    function totalSupply(address token) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x18160ddd) // `totalSupply()`.\n            if iszero(\n                and(gt(returndatasize(), 0x1f), staticcall(gas(), token, 0x1c, 0x04, 0x00, 0x20))\n            ) {\n                mstore(0x00, 0x54cd9435) // `TotalSupplyQueryFailed()`.\n                revert(0x1c, 0x04)\n            }\n            result := mload(0x00)\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) internal {\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(\n                and(\n                    call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),\n                    lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.\n                )\n            ) {\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(\n                        add(m, 0x94),\n                        lt(iszero(amount), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    )\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `amount != 0` 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( // Revert if token does not have code, or if the call fails.\n                mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))\n            ) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Approves `spender` to spend `amount` of `token` for `address(this)`.\n    function permit2Approve(address token, address spender, uint160 amount, uint48 expiration)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let addressMask := shr(96, not(0))\n            let m := mload(0x40)\n            mstore(m, 0x87517c45) // `approve(address,address,uint160,uint48)`.\n            mstore(add(m, 0x20), and(addressMask, token))\n            mstore(add(m, 0x40), and(addressMask, spender))\n            mstore(add(m, 0x60), and(addressMask, amount))\n            mstore(add(m, 0x80), and(0xffffffffffff, expiration))\n            if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0x84, codesize(), 0x00)) {\n                mstore(0x00, 0x324f14ae) // `Permit2ApproveFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Revokes an approval for `token` and `spender` for `address(this)`.\n    function permit2Lockdown(address token, address spender) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0xcc53287f) // `Permit2.lockdown`.\n            mstore(add(m, 0x20), 0x20) // Offset of the `approvals`.\n            mstore(add(m, 0x40), 1) // `approvals.length`.\n            mstore(add(m, 0x60), shr(96, shl(96, token)))\n            mstore(add(m, 0x80), shr(96, shl(96, spender)))\n            if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {\n                mstore(0x00, 0x96b3de23) // `Permit2LockdownFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.30+commit.73712a01","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"osaka","remappings":["@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","hardhat/=lib/v4-core/node_modules/hardhat/","openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/","solady/=lib/solady/src/","solmate/=lib/v4-core/lib/solmate/","v4-core/=lib/v4-core/src/"]},"name":"BurnExecutor","fullyQualifiedName":"src/BurnExecutor.sol:BurnExecutor"},"abi":[{"type":"constructor","inputs":[{"name":"owner_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"oft_","type":"address","internalType":"address"},{"name":"dstEid_","type":"uint32","internalType":"uint32"},{"name":"baseBurnReceiver_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"BelowMinBridgeAmount","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"minimum","type":"uint256","internalType":"uint256"}]},{"name":"BelowOftMinimum","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"oftMinimum","type":"uint256","internalType":"uint256"}]},{"name":"InsufficientMessageFee","type":"error","inputs":[{"name":"required","type":"uint256","internalType":"uint256"},{"name":"provided","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBridgeAmount","type":"error","inputs":[]},{"name":"InvalidBridgeConfig","type":"error","inputs":[]},{"name":"InvalidBridgeRecipient","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"Reentrancy","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"BridgeConfigUpdated","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"oft","type":"address","indexed":true,"internalType":"address"},{"name":"dstEid","type":"uint32","indexed":true,"internalType":"uint32"},{"name":"baseBurnReceiver","type":"address","indexed":false,"internalType":"address"},{"name":"extraOptions","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"ETHRescued","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinBridgeAmountUpdated","type":"event","inputs":[{"name":"minBridgeAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"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":"TokenRescued","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"TokensBridgedForBurn","type":"event","inputs":[{"name":"oft","type":"address","indexed":true,"internalType":"address"},{"name":"dstEid","type":"uint32","indexed":true,"internalType":"uint32"},{"name":"to","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"minAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"guid","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"name":"BASE_MAINNET_EID","type":"function","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"uint32"}],"stateMutability":"view"},{"name":"DEFAULT_BASE_BURN_RECEIVER","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"IMD_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"baseBurnReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"},{"name":"refundTo","type":"address","internalType":"address"}],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"dstEid","type":"function","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"uint32"}],"stateMutability":"view"},{"name":"extraOptions","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"view"},{"name":"minBridgeAmount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"oft","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"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":"previewBridge","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"amountToSend","type":"uint256","internalType":"uint256"},{"name":"minAmountToReceive","type":"uint256","internalType":"uint256"},{"name":"nativeFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"previewBridge","type":"function","inputs":[],"outputs":[{"name":"amountToSend","type":"uint256","internalType":"uint256"},{"name":"minAmountToReceive","type":"uint256","internalType":"uint256"},{"name":"nativeFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"quoteBridgeFee","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"stateMutability":"view"},{"name":"quoteBridgeFee","type":"function","inputs":[],"outputs":[{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"rescueETH","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"resolveSendParam","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"sendParam","type":"tuple","components":[{"name":"dstEid","type":"uint32","internalType":"uint32"},{"name":"to","type":"bytes32","internalType":"bytes32"},{"name":"amountLD","type":"uint256","internalType":"uint256"},{"name":"minAmountLD","type":"uint256","internalType":"uint256"},{"name":"extraOptions","type":"bytes","internalType":"bytes"},{"name":"composeMsg","type":"bytes","internalType":"bytes"},{"name":"oftCmd","type":"bytes","internalType":"bytes"}],"internalType":"struct SendParam"}],"stateMutability":"view"},{"name":"setBaseBurnReceiver","type":"function","inputs":[{"name":"baseBurnReceiver_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBridgeConfig","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"oft_","type":"address","internalType":"address"},{"name":"dstEid_","type":"uint32","internalType":"uint32"},{"name":"baseBurnReceiver_","type":"address","internalType":"address"},{"name":"extraOptions_","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setExtraOptions","type":"function","inputs":[{"name":"extraOptions_","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMinBridgeAmount","type":"function","inputs":[{"name":"minBridgeAmount_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"tokenBalance","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.30+commit.73712a01"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"address","name":"token_","type":"address"},{"internalType":"address","name":"oft_","type":"address"},{"internalType":"uint32","name":"dstEid_","type":"uint32"},{"internalType":"address","name":"baseBurnReceiver_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"minimum","type":"uint256"}],"name":"BelowMinBridgeAmount","type":"error"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"oftMinimum","type":"uint256"}],"name":"BelowOftMinimum","type":"error"},{"inputs":[{"internalType":"uint256","name":"required","type":"uint256"},{"internalType":"uint256","name":"provided","type":"uint256"}],"name":"InsufficientMessageFee","type":"error"},{"inputs":[],"name":"InvalidBridgeAmount","type":"error"},{"inputs":[],"name":"InvalidBridgeConfig","type":"error"},{"inputs":[],"name":"InvalidBridgeRecipient","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"Reentrancy","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"oft","type":"address"},{"indexed":true,"internalType":"uint32","name":"dstEid","type":"uint32"},{"indexed":false,"internalType":"address","name":"baseBurnReceiver","type":"address"},{"indexed":false,"internalType":"bytes","name":"extraOptions","type":"bytes"}],"name":"BridgeConfigUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ETHRescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"minBridgeAmount","type":"uint256"}],"name":"MinBridgeAmountUpdated","type":"event"},{"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":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"TokenRescued","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oft","type":"address"},{"indexed":true,"internalType":"uint32","name":"dstEid","type":"uint32"},{"indexed":true,"internalType":"bytes32","name":"to","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"minAmount","type":"uint256"},{"indexed":false,"internalType":"bytes32","name":"guid","type":"bytes32"}],"name":"TokensBridgedForBurn","type":"event"},{"inputs":[],"name":"BASE_MAINNET_EID","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_BASE_BURN_RECEIVER","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"IMD_TOKEN","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseBurnReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"}],"name":"bridgeToBaseBurnReceiver","outputs":[{"components":[{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"},{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"internalType":"struct MessagingReceipt","name":"msgReceipt","type":"tuple"},{"components":[{"internalType":"uint256","name":"amountSentLD","type":"uint256"},{"internalType":"uint256","name":"amountReceivedLD","type":"uint256"}],"internalType":"struct OFTReceipt","name":"oftReceipt","type":"tuple"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"bridgeToBaseBurnReceiver","outputs":[{"components":[{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"},{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"internalType":"struct MessagingReceipt","name":"msgReceipt","type":"tuple"},{"components":[{"internalType":"uint256","name":"amountSentLD","type":"uint256"},{"internalType":"uint256","name":"amountReceivedLD","type":"uint256"}],"internalType":"struct OFTReceipt","name":"oftReceipt","type":"tuple"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"},{"internalType":"address","name":"refundTo","type":"address"}],"name":"bridgeToBaseBurnReceiver","outputs":[{"components":[{"internalType":"bytes32","name":"guid","type":"bytes32"},{"internalType":"uint64","name":"nonce","type":"uint64"},{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"internalType":"struct MessagingReceipt","name":"msgReceipt","type":"tuple"},{"components":[{"internalType":"uint256","name":"amountSentLD","type":"uint256"},{"internalType":"uint256","name":"amountReceivedLD","type":"uint256"}],"internalType":"struct OFTReceipt","name":"oftReceipt","type":"tuple"}],"stateMutability":"payable","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":"dstEid","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extraOptions","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minBridgeAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oft","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"uint256","name":"requested","type":"uint256"}],"name":"previewBridge","outputs":[{"internalType":"uint256","name":"amountToSend","type":"uint256"},{"internalType":"uint256","name":"minAmountToReceive","type":"uint256"},{"internalType":"uint256","name":"nativeFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"previewBridge","outputs":[{"internalType":"uint256","name":"amountToSend","type":"uint256"},{"internalType":"uint256","name":"minAmountToReceive","type":"uint256"},{"internalType":"uint256","name":"nativeFee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"}],"name":"quoteBridgeFee","outputs":[{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"quoteBridgeFee","outputs":[{"components":[{"internalType":"uint256","name":"nativeFee","type":"uint256"},{"internalType":"uint256","name":"lzTokenFee","type":"uint256"}],"internalType":"struct MessagingFee","name":"fee","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueETH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"requested","type":"uint256"}],"name":"resolveSendParam","outputs":[{"components":[{"internalType":"uint32","name":"dstEid","type":"uint32"},{"internalType":"bytes32","name":"to","type":"bytes32"},{"internalType":"uint256","name":"amountLD","type":"uint256"},{"internalType":"uint256","name":"minAmountLD","type":"uint256"},{"internalType":"bytes","name":"extraOptions","type":"bytes"},{"internalType":"bytes","name":"composeMsg","type":"bytes"},{"internalType":"bytes","name":"oftCmd","type":"bytes"}],"internalType":"struct SendParam","name":"sendParam","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"baseBurnReceiver_","type":"address"}],"name":"setBaseBurnReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"address","name":"oft_","type":"address"},{"internalType":"uint32","name":"dstEid_","type":"uint32"},{"internalType":"address","name":"baseBurnReceiver_","type":"address"},{"internalType":"bytes","name":"extraOptions_","type":"bytes"}],"name":"setBridgeConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"extraOptions_","type":"bytes"}],"name":"setExtraOptions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"minBridgeAmount_","type":"uint256"}],"name":"setMinBridgeAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"token","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"}],"devdoc":{"details":"Bridging is permissionless because the only reachable destination is the owner-configured burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's own limits, so a stale or oversized request is clamped instead of reverting.","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."}],"Reentrancy()":[{"details":"Unauthorized reentrant call."}],"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."}},"kind":"dev","methods":{"bridgeToBaseBurnReceiver(uint256,address)":{"details":"Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`."},"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`."},"previewBridge(uint256)":{"returns":{"amountToSend":"Tokens debited here, already clamped to the balance, OFT limits, and dust.","minAmountToReceive":"Tokens credited to the Base burn receiver.","nativeFee":"Wei the call must be funded with. All three are zero when nothing is bridgeable."}},"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."},"resolveSendParam(uint256)":{"details":"Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer a zero over a revert."},"transferOwnership(address)":{"details":"Allows the owner to transfer the ownership to `newOwner`."}},"version":1},"userdoc":{"kind":"user","methods":{"bridgeToBaseBurnReceiver()":{"notice":"Bridges everything currently sendable."},"bridgeToBaseBurnReceiver(uint256,address)":{"notice":"Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver."},"minBridgeAmount()":{"notice":"Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor."},"previewBridge()":{"notice":"Non-reverting preview of bridging everything currently held."},"previewBridge(uint256)":{"notice":"Non-reverting view of what a bridge of `requested` would move and cost."},"rescueETH(address,uint256)":{"notice":"Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so a normal bridge never leaves ETH here."},"resolveSendParam(uint256)":{"notice":"Resolves `requested` into the exact parameters a bridge call would use right now."}},"notice":"Holds sold tokens until anyone bridges them to the Base burn receiver.","version":1}},"settings":{"compilationTarget":{"src/BurnExecutor.sol":"BurnExecutor"},"evmVersion":"osaka","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@ensdomains/=lib/v4-core/node_modules/@ensdomains/",":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/",":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/",":erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":hardhat/=lib/v4-core/node_modules/hardhat/",":openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/",":solady/=lib/solady/src/",":solmate/=lib/v4-core/lib/solmate/",":v4-core/=lib/v4-core/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/ReentrancyGuard.sol":{"keccak256":"0xdb28f318ec45197a6c7cc2abebed67d7cb8b965838ef962e3844423256a9ddb8","license":"MIT","urls":["bzz-raw://873cd46b77a2aeb781e7a0d131e7299151323ed884c330101a51d0727e218d98","dweb:/ipfs/QmddadCjyedztvdSgLZEyKWoRes2SqtpviSjhEbSNrkUoi"]},"lib/solady/src/utils/SafeTransferLib.sol":{"keccak256":"0x9193b1d2a20e216f7a1db9419f9d47e49535c0b34fae1a999f5196aeaa188aaf","license":"MIT","urls":["bzz-raw://d92546688bd8f128464e81f1699cc290e98bf77eb36f7376d1d07bb400527647","dweb:/ipfs/QmQWSBom1MaaBXqZXTnXZvV7Hf5zA42xzLYANkhr2vkTCv"]},"src/BurnExecutor.sol":{"keccak256":"0xa1dcc89a22b95a0edc846c7dae6a8bd5583908d11e1dc19ceba80c733beb1165","license":"MIT","urls":["bzz-raw://94e56e649cad75e2c0c95ff74357e686b8e90b183572e23cc1c8e11fb9f96fb2","dweb:/ipfs/QmY51jG9MWWqnZsMcPS5qf5QNcuQVsbqQTnWbcZQdtgB4F"]}},"version":1},"storageLayout":{"types":{"t_uint32":{"label":"uint32","encoding":"inplace","numberOfBytes":"4"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_bytes_storage":{"label":"bytes","encoding":"bytes","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":812,"label":"token","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"1","type":"t_address","astId":814,"label":"oft","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"1","type":"t_uint32","astId":816,"label":"dstEid","offset":20,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"2","type":"t_address","astId":818,"label":"baseBurnReceiver","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"3","type":"t_bytes_storage","astId":820,"label":"extraOptions","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"4","type":"t_uint256","astId":823,"label":"minBridgeAmount","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"}]},"transientStorageLayout":{"types":null,"storage":[]},"userdoc":{"kind":"user","notice":"Holds sold tokens until anyone bridges them to the Base burn receiver.","methods":{"previewBridge()":{"notice":"Non-reverting preview of bridging everything currently held."},"minBridgeAmount()":{"notice":"Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor."},"previewBridge(uint256)":{"notice":"Non-reverting view of what a bridge of `requested` would move and cost."},"resolveSendParam(uint256)":{"notice":"Resolves `requested` into the exact parameters a bridge call would use right now."},"bridgeToBaseBurnReceiver()":{"notice":"Bridges everything currently sendable."},"rescueETH(address,uint256)":{"notice":"Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so a normal bridge never leaves ETH here."},"bridgeToBaseBurnReceiver(uint256,address)":{"notice":"Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver."}},"version":1},"devdoc":{"kind":"dev","errors":{"Reentrancy()":[{"details":"Unauthorized reentrant call."}],"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."}},"details":"Bridging is permissionless because the only reachable destination is the owner-configured burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's own limits, so a stale or oversized request is clamped instead of reverting.","methods":{"owner()":{"details":"Returns the owner of the contract."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"previewBridge(uint256)":{"returns":{"nativeFee":"Wei the call must be funded with. All three are zero when nothing is bridgeable.","amountToSend":"Tokens debited here, already clamped to the balance, OFT limits, and dust.","minAmountToReceive":"Tokens credited to the Base burn receiver."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"resolveSendParam(uint256)":{"details":"Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer a zero over a revert."},"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`."},"bridgeToBaseBurnReceiver(uint256,address)":{"details":"Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`."}},"version":1},"sourceIds":{"src/BurnExecutor.sol":{"id":3},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/utils/ReentrancyGuard.sol":{"id":1},"lib/solady/src/utils/SafeTransferLib.sol":{"id":2}},"additionalInput":null,"stdJsonInput":{"sources":{"src/BurnExecutor.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\nimport {Ownable} from \"solady/auth/Ownable.sol\";\nimport {ReentrancyGuard} from \"solady/utils/ReentrancyGuard.sol\";\nimport {SafeTransferLib} from \"solady/utils/SafeTransferLib.sol\";\n\nstruct SendParam {\n    uint32 dstEid;\n    bytes32 to;\n    uint256 amountLD;\n    uint256 minAmountLD;\n    bytes extraOptions;\n    bytes composeMsg;\n    bytes oftCmd;\n}\n\nstruct MessagingFee {\n    uint256 nativeFee;\n    uint256 lzTokenFee;\n}\n\nstruct OFTLimit {\n    uint256 minAmountLD;\n    uint256 maxAmountLD;\n}\n\nstruct OFTFeeDetail {\n    int256 feeAmountLD;\n    string description;\n}\n\nstruct MessagingReceipt {\n    bytes32 guid;\n    uint64 nonce;\n    MessagingFee fee;\n}\n\nstruct OFTReceipt {\n    uint256 amountSentLD;\n    uint256 amountReceivedLD;\n}\n\ninterface IOFT {\n    function quoteOFT(SendParam calldata sendParam)\n        external\n        view\n        returns (OFTLimit memory limit, OFTFeeDetail[] memory oftFeeDetails, OFTReceipt memory receipt);\n\n    function quoteSend(SendParam calldata sendParam, bool payInLzToken) external view returns (MessagingFee memory fee);\n\n    function send(SendParam calldata sendParam, MessagingFee calldata fee, address refundAddress)\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt);\n}\n\ninterface IERC20BalanceOf {\n    function balanceOf(address owner) external view returns (uint256);\n}\n\n/// @notice Holds sold tokens until anyone bridges them to the Base burn receiver.\n/// @dev Bridging is permissionless because the only reachable destination is the owner-configured\n/// burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose\n/// where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's\n/// own limits, so a stale or oversized request is clamped instead of reverting.\ncontract BurnExecutor is Ownable, ReentrancyGuard {\n    address public constant IMD_TOKEN = 0xD34a99Bc0f67aE1bbd63C660e6d0b0dd03E263B7;\n    address public constant DEFAULT_BASE_BURN_RECEIVER = 0x4b118f0C63d09f09cB35fC6e8024A6c96493EaDA;\n    uint32 public constant BASE_MAINNET_EID = 30184;\n\n    error InvalidBridgeRecipient();\n    error InvalidBridgeAmount();\n    error InvalidBridgeConfig();\n    error InsufficientMessageFee(uint256 required, uint256 provided);\n    error BelowOftMinimum(uint256 amount, uint256 oftMinimum);\n    error BelowMinBridgeAmount(uint256 amount, uint256 minimum);\n\n    event BridgeConfigUpdated(\n        address indexed token, address indexed oft, uint32 indexed dstEid, address baseBurnReceiver, bytes extraOptions\n    );\n    event MinBridgeAmountUpdated(uint256 minBridgeAmount);\n    event TokensBridgedForBurn(\n        address indexed oft, uint32 indexed dstEid, bytes32 indexed to, uint256 amount, uint256 minAmount, bytes32 guid\n    );\n    event TokenRescued(address indexed token, address indexed to, uint256 amount);\n    event ETHRescued(address indexed to, uint256 amount);\n\n    address public token;\n    address public oft;\n    uint32 public dstEid;\n    address public baseBurnReceiver;\n    bytes public extraOptions;\n\n    /// @notice Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor.\n    uint256 public minBridgeAmount;\n\n    constructor(address owner_, address token_, address oft_, uint32 dstEid_, address baseBurnReceiver_) {\n        _initializeOwner(owner_);\n        _setBridgeConfig(token_, oft_, dstEid_, baseBurnReceiver_, \"\");\n    }\n\n    function setBridgeConfig(\n        address token_,\n        address oft_,\n        uint32 dstEid_,\n        address baseBurnReceiver_,\n        bytes calldata extraOptions_\n    ) external onlyOwner {\n        _setBridgeConfig(token_, oft_, dstEid_, baseBurnReceiver_, extraOptions_);\n    }\n\n    function setBaseBurnReceiver(address baseBurnReceiver_) external onlyOwner {\n        _setBridgeConfig(token, oft, dstEid, baseBurnReceiver_, extraOptions);\n    }\n\n    function setExtraOptions(bytes calldata extraOptions_) external onlyOwner {\n        _setBridgeConfig(token, oft, dstEid, baseBurnReceiver, extraOptions_);\n    }\n\n    function setMinBridgeAmount(uint256 minBridgeAmount_) external onlyOwner {\n        minBridgeAmount = minBridgeAmount_;\n        emit MinBridgeAmountUpdated(minBridgeAmount_);\n    }\n\n    function tokenBalance() public view returns (uint256) {\n        return IERC20BalanceOf(token).balanceOf(address(this));\n    }\n\n    /// @notice Resolves `requested` into the exact parameters a bridge call would use right now.\n    /// @dev Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer\n    /// a zero over a revert.\n    function resolveSendParam(uint256 requested) public view returns (SendParam memory sendParam) {\n        if (baseBurnReceiver == address(0)) revert InvalidBridgeRecipient();\n        if (requested == 0) revert InvalidBridgeAmount();\n\n        uint256 available = tokenBalance();\n        uint256 amount = requested < available ? requested : available;\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        sendParam = SendParam({\n            dstEid: dstEid,\n            to: bytes32(uint256(uint160(baseBurnReceiver))),\n            amountLD: 0,\n            minAmountLD: 0,\n            extraOptions: extraOptions,\n            composeMsg: \"\",\n            oftCmd: \"\"\n        });\n\n        // Probe the OFT with a zero amount first. A zero can never trip a cap, a rate limiter, or a\n        // per-message maximum, so it reports the current limits even on OFTs whose quote reverts for\n        // an oversized request. Rate-limited or capped OFTs accept less than the full balance; take\n        // what fits instead of failing.\n        (bool probed, OFTLimit memory limit,) = _tryQuoteOFT(sendParam);\n        if (probed && amount > limit.maxAmountLD) amount = limit.maxAmountLD;\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        sendParam.amountLD = amount;\n        (,, OFTReceipt memory receipt) = IOFT(oft).quoteOFT(sendParam);\n\n        // Shared-decimal dust is stripped by the OFT and stays here for the next batch.\n        if (receipt.amountSentLD == 0 || receipt.amountReceivedLD == 0) revert InvalidBridgeAmount();\n        if (receipt.amountSentLD < limit.minAmountLD) revert BelowOftMinimum(receipt.amountSentLD, limit.minAmountLD);\n\n        uint256 floorAmount = minBridgeAmount;\n        if (receipt.amountSentLD < floorAmount) revert BelowMinBridgeAmount(receipt.amountSentLD, floorAmount);\n\n        sendParam.amountLD = receipt.amountSentLD;\n        sendParam.minAmountLD = receipt.amountReceivedLD;\n    }\n\n    function _tryQuoteOFT(SendParam memory sendParam)\n        internal\n        view\n        returns (bool ok, OFTLimit memory limit, OFTReceipt memory receipt)\n    {\n        try IOFT(oft).quoteOFT(sendParam) returns (\n            OFTLimit memory limit_, OFTFeeDetail[] memory, OFTReceipt memory receipt_\n        ) {\n            return (true, limit_, receipt_);\n        } catch {\n            return (false, limit, receipt);\n        }\n    }\n\n    /// @notice Non-reverting view of what a bridge of `requested` would move and cost.\n    /// @return amountToSend Tokens debited here, already clamped to the balance, OFT limits, and dust.\n    /// @return minAmountToReceive Tokens credited to the Base burn receiver.\n    /// @return nativeFee Wei the call must be funded with. All three are zero when nothing is bridgeable.\n    function previewBridge(uint256 requested)\n        public\n        view\n        returns (uint256 amountToSend, uint256 minAmountToReceive, uint256 nativeFee)\n    {\n        try this.resolveSendParam(requested) returns (SendParam memory sendParam) {\n            try IOFT(oft).quoteSend(sendParam, false) returns (MessagingFee memory fee) {\n                return (sendParam.amountLD, sendParam.minAmountLD, fee.nativeFee);\n            } catch {\n                return (0, 0, 0);\n            }\n        } catch {\n            return (0, 0, 0);\n        }\n    }\n\n    /// @notice Non-reverting preview of bridging everything currently held.\n    function previewBridge()\n        external\n        view\n        returns (uint256 amountToSend, uint256 minAmountToReceive, uint256 nativeFee)\n    {\n        return previewBridge(type(uint256).max);\n    }\n\n    function quoteBridgeFee(uint256 requested) public view returns (MessagingFee memory fee) {\n        return IOFT(oft).quoteSend(resolveSendParam(requested), false);\n    }\n\n    function quoteBridgeFee() external view returns (MessagingFee memory fee) {\n        return quoteBridgeFee(type(uint256).max);\n    }\n\n    /// @notice Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver.\n    /// @dev Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`.\n    function bridgeToBaseBurnReceiver(uint256 requested, address refundTo)\n        public\n        payable\n        nonReentrant\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        if (refundTo == address(0)) refundTo = msg.sender;\n\n        SendParam memory sendParam = resolveSendParam(requested);\n        MessagingFee memory fee = IOFT(oft).quoteSend(sendParam, false);\n        if (msg.value < fee.nativeFee) revert InsufficientMessageFee(fee.nativeFee, msg.value);\n\n        address oft_ = oft;\n        address token_ = token;\n        SafeTransferLib.safeApproveWithRetry(token_, oft_, sendParam.amountLD);\n        (msgReceipt, oftReceipt) = IOFT(oft_).send{value: fee.nativeFee}(sendParam, fee, refundTo);\n        SafeTransferLib.safeApproveWithRetry(token_, oft_, 0);\n\n        emit TokensBridgedForBurn(\n            oft_, sendParam.dstEid, sendParam.to, oftReceipt.amountSentLD, oftReceipt.amountReceivedLD, msgReceipt.guid\n        );\n\n        uint256 surplus = msg.value - fee.nativeFee;\n        if (surplus != 0) SafeTransferLib.forceSafeTransferETH(refundTo, surplus);\n    }\n\n    function bridgeToBaseBurnReceiver(uint256 requested)\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        return bridgeToBaseBurnReceiver(requested, msg.sender);\n    }\n\n    /// @notice Bridges everything currently sendable.\n    function bridgeToBaseBurnReceiver()\n        external\n        payable\n        returns (MessagingReceipt memory msgReceipt, OFTReceipt memory oftReceipt)\n    {\n        return bridgeToBaseBurnReceiver(type(uint256).max, msg.sender);\n    }\n\n    /// @notice Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so\n    /// a normal bridge never leaves ETH here.\n    function rescueETH(address to, uint256 amount) external onlyOwner {\n        if (to == address(0)) revert InvalidBridgeRecipient();\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        SafeTransferLib.forceSafeTransferETH(to, amount);\n        emit ETHRescued(to, amount);\n    }\n\n    function rescueToken(address to, uint256 amount) external onlyOwner {\n        _rescueToken(token, to, amount);\n    }\n\n    function rescueToken(address token_, address to, uint256 amount) external onlyOwner {\n        _rescueToken(token_, to, amount);\n    }\n\n    function _rescueToken(address token_, address to, uint256 amount) internal {\n        if (to == address(0)) revert InvalidBridgeRecipient();\n        if (amount == 0) revert InvalidBridgeAmount();\n\n        SafeTransferLib.safeTransfer(token_, to, amount);\n        emit TokenRescued(token_, to, amount);\n    }\n\n    function _setBridgeConfig(\n        address token_,\n        address oft_,\n        uint32 dstEid_,\n        address baseBurnReceiver_,\n        bytes memory extraOptions_\n    ) internal {\n        if (token_ == address(0) || oft_ == address(0) || dstEid_ == 0) {\n            revert InvalidBridgeConfig();\n        }\n\n        token = token_;\n        oft = oft_;\n        dstEid = dstEid_;\n        baseBurnReceiver = baseBurnReceiver_;\n        extraOptions = extraOptions_;\n\n        emit BridgeConfigUpdated(token_, oft_, dstEid_, baseBurnReceiver_, extraOptions_);\n    }\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/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Reentrancy guard mixin.\n/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ReentrancyGuard.sol)\nabstract contract ReentrancyGuard {\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                       CUSTOM ERRORS                        */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Unauthorized reentrant call.\n    error Reentrancy();\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                          STORAGE                           */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Equivalent to: `uint72(bytes9(keccak256(\"_REENTRANCY_GUARD_SLOT\")))`.\n    /// 9 bytes is large enough to avoid collisions with lower slots,\n    /// but not too large to result in excessive bytecode bloat.\n    uint256 private constant _REENTRANCY_GUARD_SLOT = 0x929eee149b4bd21268;\n\n    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/\n    /*                      REENTRANCY GUARD                      */\n    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/\n\n    /// @dev Guards a function from reentrancy.\n    modifier nonReentrant() virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {\n                mstore(0x00, 0xab143c06) // `Reentrancy()`.\n                revert(0x1c, 0x04)\n            }\n            sstore(_REENTRANCY_GUARD_SLOT, address())\n        }\n        _;\n        /// @solidity memory-safe-assembly\n        assembly {\n            sstore(_REENTRANCY_GUARD_SLOT, codesize())\n        }\n    }\n\n    /// @dev Guards a view function from read-only reentrancy.\n    modifier nonReadReentrant() virtual {\n        /// @solidity memory-safe-assembly\n        assembly {\n            if eq(sload(_REENTRANCY_GUARD_SLOT), address()) {\n                mstore(0x00, 0xab143c06) // `Reentrancy()`.\n                revert(0x1c, 0x04)\n            }\n        }\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.\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 ERC20 `totalSupply` query has failed.\n    error TotalSupplyQueryFailed();\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    /// @dev The Permit2 approve operation has failed.\n    error Permit2ApproveFailed();\n\n    /// @dev The Permit2 lockdown operation has failed.\n    error Permit2LockdownFailed();\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 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    /// @dev The canonical address of the `SELFDESTRUCT` ETH mover.\n    /// See: https://gist.github.com/Vectorized/1cb8ad4cf393b1378e08f23f79bd99fa\n    /// [Etherscan](https://etherscan.io/address/0x00000000000073c48c8055bD43D1A53799176f0D)\n    address internal constant ETH_MOVER = 0x00000000000073c48c8055bD43D1A53799176f0D;\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)) {\n                    revert(codesize(), codesize())\n                } // 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\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) internal returns (bool success) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)\n        }\n    }\n\n    /// @dev Force transfers ETH to `to`, without triggering the fallback (if any).\n    /// This method attempts to use a separate contract to send via `SELFDESTRUCT`,\n    /// and upon failure, deploys a minimal vault to accrue the ETH.\n    function safeMoveETH(address to, uint256 amount) internal returns (address vault) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            to := shr(96, shl(96, to)) // Clean upper 96 bits.\n            for { let mover := ETH_MOVER } iszero(eq(to, address())) {} {\n                let selfBalanceBefore := selfbalance()\n                if or(lt(selfBalanceBefore, amount), eq(to, mover)) {\n                    mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.\n                    revert(0x1c, 0x04)\n                }\n                if extcodesize(mover) {\n                    let balanceBefore := balance(to) // Check via delta, in case `SELFDESTRUCT` is bricked.\n                    mstore(0x00, to)\n                    pop(call(gas(), mover, amount, 0x00, 0x20, codesize(), 0x00))\n                    // If `address(to).balance >= amount + balanceBefore`, skip vault workflow.\n                    if iszero(lt(balance(to), add(amount, balanceBefore))) { break }\n                    // Just in case `SELFDESTRUCT` is changed to not revert and do nothing.\n                    if lt(selfBalanceBefore, selfbalance()) { invalid() }\n                }\n                let m := mload(0x40)\n                // If the mover is missing or bricked, deploy a minimal vault\n                // that withdraws all ETH to `to` when being called only by `to`.\n                // forgefmt: disable-next-item\n                mstore(add(m, 0x20), 0x33146025575b600160005260206000f35b3d3d3d3d47335af1601a5760003dfd)\n                mstore(m, or(to, shl(160, 0x6035600b3d3960353df3fe73)))\n                // Compute and store the bytecode hash.\n                mstore8(0x00, 0xff) // Write the prefix.\n                mstore(0x35, keccak256(m, 0x40))\n                mstore(0x01, shl(96, address())) // Deployer.\n                mstore(0x15, 0) // Salt.\n                vault := keccak256(0x00, 0x55)\n                pop(call(gas(), vault, amount, codesize(), 0x00, codesize(), 0x00))\n                // The vault returns a single word on success. Failure reverts with empty data.\n                if iszero(returndatasize()) {\n                    if iszero(create2(0, m, 0x40, 0)) { revert(codesize(), codesize()) } // For gas estimation.\n                }\n                mstore(0x40, m) // Restore the free memory pointer.\n                break\n            }\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            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\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 := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                success := lt(or(iszero(extcodesize(token)), returndatasize()), success)\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            let success := call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x7939f424) // `TransferFromFailed()`.\n                    revert(0x1c, 0x04)\n                }\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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                    mstore(0x00, 0x90b8ec18) // `TransferFailed()`.\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\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 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            let success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n            if iszero(and(eq(mload(0x00), 1), success)) {\n                if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\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                    success := call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)\n                    if iszero(and(eq(mload(0x00), 1), success)) {\n                        // Check the `extcodesize` again just in case the token selfdestructs lol.\n                        if iszero(lt(or(iszero(extcodesize(token)), returndatasize()), success)) {\n                            mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.\n                            revert(0x1c, 0x04)\n                        }\n                    }\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 := 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 Performs a `token.balanceOf(account)` check.\n    /// `implemented` denotes whether the `token` does not implement `balanceOf`.\n    /// `amount` is zero if the `token` does not implement `balanceOf`.\n    function checkBalanceOf(address token, address account)\n        internal\n        view\n        returns (bool implemented, uint256 amount)\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x14, account) // Store the `account` argument.\n            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.\n            implemented := 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            amount := mul(mload(0x20), implemented)\n        }\n    }\n\n    /// @dev Returns the total supply of the `token`.\n    /// Reverts if the token does not exist or does not implement `totalSupply()`.\n    function totalSupply(address token) internal view returns (uint256 result) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, 0x18160ddd) // `totalSupply()`.\n            if iszero(\n                and(gt(returndatasize(), 0x1f), staticcall(gas(), token, 0x1c, 0x04, 0x00, 0x20))\n            ) {\n                mstore(0x00, 0x54cd9435) // `TotalSupplyQueryFailed()`.\n                revert(0x1c, 0x04)\n            }\n            result := mload(0x00)\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) internal {\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(\n                and(\n                    call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00),\n                    lt(iszero(extcodesize(token)), exists) // Token has code and Permit2 exists.\n                )\n            ) {\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(\n                        add(m, 0x94),\n                        lt(iszero(amount), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))\n                    )\n                    mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.\n                    // `nonces` is already at `add(m, 0x54)`.\n                    // `amount != 0` 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( // Revert if token does not have code, or if the call fails.\n                mul(extcodesize(token), call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00))\n            ) {\n                mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Approves `spender` to spend `amount` of `token` for `address(this)`.\n    function permit2Approve(address token, address spender, uint160 amount, uint48 expiration)\n        internal\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let addressMask := shr(96, not(0))\n            let m := mload(0x40)\n            mstore(m, 0x87517c45) // `approve(address,address,uint160,uint48)`.\n            mstore(add(m, 0x20), and(addressMask, token))\n            mstore(add(m, 0x40), and(addressMask, spender))\n            mstore(add(m, 0x60), and(addressMask, amount))\n            mstore(add(m, 0x80), and(0xffffffffffff, expiration))\n            if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0x84, codesize(), 0x00)) {\n                mstore(0x00, 0x324f14ae) // `Permit2ApproveFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n\n    /// @dev Revokes an approval for `token` and `spender` for `address(this)`.\n    function permit2Lockdown(address token, address spender) internal {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let m := mload(0x40)\n            mstore(m, 0xcc53287f) // `Permit2.lockdown`.\n            mstore(add(m, 0x20), 0x20) // Offset of the `approvals`.\n            mstore(add(m, 0x40), 1) // `approvals.length`.\n            mstore(add(m, 0x60), shr(96, shl(96, token)))\n            mstore(add(m, 0x80), shr(96, shl(96, spender)))\n            if iszero(call(gas(), PERMIT2, 0, add(m, 0x1c), 0xa0, codesize(), 0x00)) {\n                mstore(0x00, 0x96b3de23) // `Permit2LockdownFailed()`.\n                revert(0x1c, 0x04)\n            }\n        }\n    }\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":true,"bytecodeHash":"ipfs","useLiteralContent":false},"optimizer":{"runs":200,"enabled":true},"evmVersion":"osaka","remappings":["@ensdomains/=lib/v4-core/node_modules/@ensdomains/","@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/","ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/","erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","hardhat/=lib/v4-core/node_modules/hardhat/","openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/","solady/=lib/solady/src/","solmate/=lib/v4-core/lib/solmate/","v4-core/=lib/v4-core/src/"]}},"stdJsonOutput":{"sources":{"src/BurnExecutor.sol":{"id":3},"lib/solady/src/auth/Ownable.sol":{"id":0},"lib/solady/src/utils/ReentrancyGuard.sol":{"id":1},"lib/solady/src/utils/SafeTransferLib.sol":{"id":2}},"contracts":{"src/BurnExecutor.sol":{"BurnExecutor":{"abi":[{"type":"constructor","inputs":[{"name":"owner_","type":"address","internalType":"address"},{"name":"token_","type":"address","internalType":"address"},{"name":"oft_","type":"address","internalType":"address"},{"name":"dstEid_","type":"uint32","internalType":"uint32"},{"name":"baseBurnReceiver_","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"AlreadyInitialized","type":"error","inputs":[]},{"name":"BelowMinBridgeAmount","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"minimum","type":"uint256","internalType":"uint256"}]},{"name":"BelowOftMinimum","type":"error","inputs":[{"name":"amount","type":"uint256","internalType":"uint256"},{"name":"oftMinimum","type":"uint256","internalType":"uint256"}]},{"name":"InsufficientMessageFee","type":"error","inputs":[{"name":"required","type":"uint256","internalType":"uint256"},{"name":"provided","type":"uint256","internalType":"uint256"}]},{"name":"InvalidBridgeAmount","type":"error","inputs":[]},{"name":"InvalidBridgeConfig","type":"error","inputs":[]},{"name":"InvalidBridgeRecipient","type":"error","inputs":[]},{"name":"NewOwnerIsZeroAddress","type":"error","inputs":[]},{"name":"NoHandoverRequest","type":"error","inputs":[]},{"name":"Reentrancy","type":"error","inputs":[]},{"name":"Unauthorized","type":"error","inputs":[]},{"name":"BridgeConfigUpdated","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"oft","type":"address","indexed":true,"internalType":"address"},{"name":"dstEid","type":"uint32","indexed":true,"internalType":"uint32"},{"name":"baseBurnReceiver","type":"address","indexed":false,"internalType":"address"},{"name":"extraOptions","type":"bytes","indexed":false,"internalType":"bytes"}],"anonymous":false},{"name":"ETHRescued","type":"event","inputs":[{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"MinBridgeAmountUpdated","type":"event","inputs":[{"name":"minBridgeAmount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"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":"TokenRescued","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"TokensBridgedForBurn","type":"event","inputs":[{"name":"oft","type":"address","indexed":true,"internalType":"address"},{"name":"dstEid","type":"uint32","indexed":true,"internalType":"uint32"},{"name":"to","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"minAmount","type":"uint256","indexed":false,"internalType":"uint256"},{"name":"guid","type":"bytes32","indexed":false,"internalType":"bytes32"}],"anonymous":false},{"name":"BASE_MAINNET_EID","type":"function","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"uint32"}],"stateMutability":"view"},{"name":"DEFAULT_BASE_BURN_RECEIVER","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"IMD_TOKEN","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"baseBurnReceiver","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"bridgeToBaseBurnReceiver","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"},{"name":"refundTo","type":"address","internalType":"address"}],"outputs":[{"name":"msgReceipt","type":"tuple","components":[{"name":"guid","type":"bytes32","internalType":"bytes32"},{"name":"nonce","type":"uint64","internalType":"uint64"},{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"internalType":"struct MessagingReceipt"},{"name":"oftReceipt","type":"tuple","components":[{"name":"amountSentLD","type":"uint256","internalType":"uint256"},{"name":"amountReceivedLD","type":"uint256","internalType":"uint256"}],"internalType":"struct OFTReceipt"}],"stateMutability":"payable"},{"name":"cancelOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"completeOwnershipHandover","type":"function","inputs":[{"name":"pendingOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"},{"name":"dstEid","type":"function","inputs":[],"outputs":[{"name":"","type":"uint32","internalType":"uint32"}],"stateMutability":"view"},{"name":"extraOptions","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes","internalType":"bytes"}],"stateMutability":"view"},{"name":"minBridgeAmount","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"oft","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"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":"previewBridge","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"amountToSend","type":"uint256","internalType":"uint256"},{"name":"minAmountToReceive","type":"uint256","internalType":"uint256"},{"name":"nativeFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"previewBridge","type":"function","inputs":[],"outputs":[{"name":"amountToSend","type":"uint256","internalType":"uint256"},{"name":"minAmountToReceive","type":"uint256","internalType":"uint256"},{"name":"nativeFee","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"quoteBridgeFee","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"stateMutability":"view"},{"name":"quoteBridgeFee","type":"function","inputs":[],"outputs":[{"name":"fee","type":"tuple","components":[{"name":"nativeFee","type":"uint256","internalType":"uint256"},{"name":"lzTokenFee","type":"uint256","internalType":"uint256"}],"internalType":"struct MessagingFee"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"requestOwnershipHandover","type":"function","inputs":[],"outputs":[],"stateMutability":"payable"},{"name":"rescueETH","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"rescueToken","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"resolveSendParam","type":"function","inputs":[{"name":"requested","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"sendParam","type":"tuple","components":[{"name":"dstEid","type":"uint32","internalType":"uint32"},{"name":"to","type":"bytes32","internalType":"bytes32"},{"name":"amountLD","type":"uint256","internalType":"uint256"},{"name":"minAmountLD","type":"uint256","internalType":"uint256"},{"name":"extraOptions","type":"bytes","internalType":"bytes"},{"name":"composeMsg","type":"bytes","internalType":"bytes"},{"name":"oftCmd","type":"bytes","internalType":"bytes"}],"internalType":"struct SendParam"}],"stateMutability":"view"},{"name":"setBaseBurnReceiver","type":"function","inputs":[{"name":"baseBurnReceiver_","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setBridgeConfig","type":"function","inputs":[{"name":"token_","type":"address","internalType":"address"},{"name":"oft_","type":"address","internalType":"address"},{"name":"dstEid_","type":"uint32","internalType":"uint32"},{"name":"baseBurnReceiver_","type":"address","internalType":"address"},{"name":"extraOptions_","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setExtraOptions","type":"function","inputs":[{"name":"extraOptions_","type":"bytes","internalType":"bytes"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMinBridgeAmount","type":"function","inputs":[{"name":"minBridgeAmount_","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"token","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"tokenBalance","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.30+commit.73712a01\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oft_\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"dstEid_\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"baseBurnReceiver_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[],\"name\":\"AlreadyInitialized\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minimum\",\"type\":\"uint256\"}],\"name\":\"BelowMinBridgeAmount\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"oftMinimum\",\"type\":\"uint256\"}],\"name\":\"BelowOftMinimum\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"required\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"provided\",\"type\":\"uint256\"}],\"name\":\"InsufficientMessageFee\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBridgeAmount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBridgeConfig\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidBridgeRecipient\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NewOwnerIsZeroAddress\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"NoHandoverRequest\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Reentrancy\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"Unauthorized\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oft\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"dstEid\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"baseBurnReceiver\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"extraOptions\",\"type\":\"bytes\"}],\"name\":\"BridgeConfigUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ETHRescued\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"minBridgeAmount\",\"type\":\"uint256\"}],\"name\":\"MinBridgeAmountUpdated\",\"type\":\"event\"},{\"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\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"TokenRescued\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"oft\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"uint32\",\"name\":\"dstEid\",\"type\":\"uint32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"to\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"minAmount\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"guid\",\"type\":\"bytes32\"}],\"name\":\"TokensBridgedForBurn\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BASE_MAINNET_EID\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DEFAULT_BASE_BURN_RECEIVER\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"IMD_TOKEN\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"baseBurnReceiver\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"}],\"name\":\"bridgeToBaseBurnReceiver\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"guid\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lzTokenFee\",\"type\":\"uint256\"}],\"internalType\":\"struct MessagingFee\",\"name\":\"fee\",\"type\":\"tuple\"}],\"internalType\":\"struct MessagingReceipt\",\"name\":\"msgReceipt\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"amountSentLD\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountReceivedLD\",\"type\":\"uint256\"}],\"internalType\":\"struct OFTReceipt\",\"name\":\"oftReceipt\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"bridgeToBaseBurnReceiver\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"guid\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lzTokenFee\",\"type\":\"uint256\"}],\"internalType\":\"struct MessagingFee\",\"name\":\"fee\",\"type\":\"tuple\"}],\"internalType\":\"struct MessagingReceipt\",\"name\":\"msgReceipt\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"amountSentLD\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountReceivedLD\",\"type\":\"uint256\"}],\"internalType\":\"struct OFTReceipt\",\"name\":\"oftReceipt\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"refundTo\",\"type\":\"address\"}],\"name\":\"bridgeToBaseBurnReceiver\",\"outputs\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"guid\",\"type\":\"bytes32\"},{\"internalType\":\"uint64\",\"name\":\"nonce\",\"type\":\"uint64\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lzTokenFee\",\"type\":\"uint256\"}],\"internalType\":\"struct MessagingFee\",\"name\":\"fee\",\"type\":\"tuple\"}],\"internalType\":\"struct MessagingReceipt\",\"name\":\"msgReceipt\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"amountSentLD\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"amountReceivedLD\",\"type\":\"uint256\"}],\"internalType\":\"struct OFTReceipt\",\"name\":\"oftReceipt\",\"type\":\"tuple\"}],\"stateMutability\":\"payable\",\"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\":\"dstEid\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"extraOptions\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"minBridgeAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"oft\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"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\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"}],\"name\":\"previewBridge\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountToSend\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToReceive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"previewBridge\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"amountToSend\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minAmountToReceive\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"}],\"name\":\"quoteBridgeFee\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lzTokenFee\",\"type\":\"uint256\"}],\"internalType\":\"struct MessagingFee\",\"name\":\"fee\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"quoteBridgeFee\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"nativeFee\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"lzTokenFee\",\"type\":\"uint256\"}],\"internalType\":\"struct MessagingFee\",\"name\":\"fee\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"requestOwnershipHandover\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"rescueETH\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"rescueToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"rescueToken\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"requested\",\"type\":\"uint256\"}],\"name\":\"resolveSendParam\",\"outputs\":[{\"components\":[{\"internalType\":\"uint32\",\"name\":\"dstEid\",\"type\":\"uint32\"},{\"internalType\":\"bytes32\",\"name\":\"to\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"amountLD\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"minAmountLD\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"extraOptions\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"composeMsg\",\"type\":\"bytes\"},{\"internalType\":\"bytes\",\"name\":\"oftCmd\",\"type\":\"bytes\"}],\"internalType\":\"struct SendParam\",\"name\":\"sendParam\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"baseBurnReceiver_\",\"type\":\"address\"}],\"name\":\"setBaseBurnReceiver\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token_\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"oft_\",\"type\":\"address\"},{\"internalType\":\"uint32\",\"name\":\"dstEid_\",\"type\":\"uint32\"},{\"internalType\":\"address\",\"name\":\"baseBurnReceiver_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"extraOptions_\",\"type\":\"bytes\"}],\"name\":\"setBridgeConfig\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"extraOptions_\",\"type\":\"bytes\"}],\"name\":\"setExtraOptions\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"minBridgeAmount_\",\"type\":\"uint256\"}],\"name\":\"setMinBridgeAmount\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"token\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"tokenBalance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"Bridging is permissionless because the only reachable destination is the owner-configured burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's own limits, so a stale or oversized request is clamped instead of reverting.\",\"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.\"}],\"Reentrancy()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"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.\"}},\"kind\":\"dev\",\"methods\":{\"bridgeToBaseBurnReceiver(uint256,address)\":{\"details\":\"Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`.\"},\"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`.\"},\"previewBridge(uint256)\":{\"returns\":{\"amountToSend\":\"Tokens debited here, already clamped to the balance, OFT limits, and dust.\",\"minAmountToReceive\":\"Tokens credited to the Base burn receiver.\",\"nativeFee\":\"Wei the call must be funded with. All three are zero when nothing is bridgeable.\"}},\"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.\"},\"resolveSendParam(uint256)\":{\"details\":\"Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer a zero over a revert.\"},\"transferOwnership(address)\":{\"details\":\"Allows the owner to transfer the ownership to `newOwner`.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"bridgeToBaseBurnReceiver()\":{\"notice\":\"Bridges everything currently sendable.\"},\"bridgeToBaseBurnReceiver(uint256,address)\":{\"notice\":\"Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver.\"},\"minBridgeAmount()\":{\"notice\":\"Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor.\"},\"previewBridge()\":{\"notice\":\"Non-reverting preview of bridging everything currently held.\"},\"previewBridge(uint256)\":{\"notice\":\"Non-reverting view of what a bridge of `requested` would move and cost.\"},\"rescueETH(address,uint256)\":{\"notice\":\"Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so a normal bridge never leaves ETH here.\"},\"resolveSendParam(uint256)\":{\"notice\":\"Resolves `requested` into the exact parameters a bridge call would use right now.\"}},\"notice\":\"Holds sold tokens until anyone bridges them to the Base burn receiver.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"src/BurnExecutor.sol\":\"BurnExecutor\"},\"evmVersion\":\"osaka\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@ensdomains/=lib/v4-core/node_modules/@ensdomains/\",\":@openzeppelin/=lib/v4-core/lib/openzeppelin-contracts/\",\":ds-test/=lib/v4-core/lib/forge-std/lib/ds-test/src/\",\":erc4626-tests/=lib/v4-core/lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":hardhat/=lib/v4-core/node_modules/hardhat/\",\":openzeppelin-contracts/=lib/v4-core/lib/openzeppelin-contracts/\",\":solady/=lib/solady/src/\",\":solmate/=lib/v4-core/lib/solmate/\",\":v4-core/=lib/v4-core/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/ReentrancyGuard.sol\":{\"keccak256\":\"0xdb28f318ec45197a6c7cc2abebed67d7cb8b965838ef962e3844423256a9ddb8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://873cd46b77a2aeb781e7a0d131e7299151323ed884c330101a51d0727e218d98\",\"dweb:/ipfs/QmddadCjyedztvdSgLZEyKWoRes2SqtpviSjhEbSNrkUoi\"]},\"lib/solady/src/utils/SafeTransferLib.sol\":{\"keccak256\":\"0x9193b1d2a20e216f7a1db9419f9d47e49535c0b34fae1a999f5196aeaa188aaf\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://d92546688bd8f128464e81f1699cc290e98bf77eb36f7376d1d07bb400527647\",\"dweb:/ipfs/QmQWSBom1MaaBXqZXTnXZvV7Hf5zA42xzLYANkhr2vkTCv\"]},\"src/BurnExecutor.sol\":{\"keccak256\":\"0xa1dcc89a22b95a0edc846c7dae6a8bd5583908d11e1dc19ceba80c733beb1165\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://94e56e649cad75e2c0c95ff74357e686b8e90b183572e23cc1c8e11fb9f96fb2\",\"dweb:/ipfs/QmY51jG9MWWqnZsMcPS5qf5QNcuQVsbqQTnWbcZQdtgB4F\"]}},\"version\":1}","userdoc":{"kind":"user","notice":"Holds sold tokens until anyone bridges them to the Base burn receiver.","methods":{"previewBridge()":{"notice":"Non-reverting preview of bridging everything currently held."},"minBridgeAmount()":{"notice":"Smallest batch a permissionless caller may bridge, in local decimals. Zero disables the floor."},"previewBridge(uint256)":{"notice":"Non-reverting view of what a bridge of `requested` would move and cost."},"resolveSendParam(uint256)":{"notice":"Resolves `requested` into the exact parameters a bridge call would use right now."},"bridgeToBaseBurnReceiver()":{"notice":"Bridges everything currently sendable."},"rescueETH(address,uint256)":{"notice":"Recovers native ETH force-sent to this contract. Fee surplus is refunded in-call, so a normal bridge never leaves ETH here."},"bridgeToBaseBurnReceiver(uint256,address)":{"notice":"Bridges `requested` tokens (clamped to what is actually sendable) to the Base burn receiver."}},"version":1},"devdoc":{"kind":"dev","errors":{"Reentrancy()":[{"details":"Unauthorized reentrant call."}],"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."}},"details":"Bridging is permissionless because the only reachable destination is the owner-configured burn receiver: a caller can choose the batch size and pays the LayerZero fee, but cannot choose where the tokens go. Every amount is resolved on-chain against the live balance and the OFT's own limits, so a stale or oversized request is clamped instead of reverting.","methods":{"owner()":{"details":"Returns the owner of the contract."},"renounceOwnership()":{"details":"Allows the owner to renounce their ownership."},"previewBridge(uint256)":{"returns":{"nativeFee":"Wei the call must be funded with. All three are zero when nothing is bridgeable.","amountToSend":"Tokens debited here, already clamped to the balance, OFT limits, and dust.","minAmountToReceive":"Tokens credited to the Base burn receiver."}},"cancelOwnershipHandover()":{"details":"Cancels the two-step ownership handover to the caller, if any."},"resolveSendParam(uint256)":{"details":"Reverts when nothing is bridgeable. `previewBridge` wraps this for callers that prefer a zero over a revert."},"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`."},"bridgeToBaseBurnReceiver(uint256,address)":{"details":"Callable by anyone. Overpaying is safe: the surplus is returned to `refundTo`."}},"version":1},"storageLayout":{"types":{"t_uint32":{"label":"uint32","encoding":"inplace","numberOfBytes":"4"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_bytes_storage":{"label":"bytes","encoding":"bytes","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":812,"label":"token","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"1","type":"t_address","astId":814,"label":"oft","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"1","type":"t_uint32","astId":816,"label":"dstEid","offset":20,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"2","type":"t_address","astId":818,"label":"baseBurnReceiver","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"3","type":"t_bytes_storage","astId":820,"label":"extraOptions","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"},{"slot":"4","type":"t_uint256","astId":823,"label":"minBridgeAmount","offset":0,"contract":"src/BurnExecutor.sol:BurnExecutor"}]},"transientStorageLayout":{"types":null,"storage":[]},"evm":{"bytecode":{"object":"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","sourceMap":"1898:10149:3:-:0;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;5710:347:0;;;-1:-1:-1;;5710:347:0;;;-1:-1:-1;5710:347:0;-1:-1:-1;;5710:347:0;1898:10149:3;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;1898:10149:3;;11679:20;;:42;;;;-1:-1:-1;11679:58:3;;;;-1:-1:-1;11675:117:3;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;5710:347:0;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;11872:36;1898:10149;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;11918:28;1898:10149;11826:10;1898:10149;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;;;11826:10;1898:10149;;;;;11918:28;1898:10149;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;1898:10149:3;;;11962:76;;;;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11918:28;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;11826:10;1898:10149;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;11918:28;1898:10149;;;;;;;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11826:10;1898:10149;;;;;;;;11918:28;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;11826:10;1898:10149;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;11675:117;11760:21;;;-1:-1:-1;11760:21:3;;-1:-1:-1;11760:21:3;11679:58;11725:12;;;11679:58;;:42;-1:-1:-1;;;;;;1898:10149:3;;11703:18;11679:42;;1898:10149;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1898:10149:3:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;11885:237:0;;;1898:10149:3;11885:237:0;1898:10149:3;11885:237:0;;;;1898:10149:3;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;:::i;:::-;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;8479:183;;;;;;8681:8;;;:::i;:::-;1898:10149:3;8479:183:0;;1898:10149:3;8479:183:0;1898:10149:3;8479:183:0;;1898:10149:3;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;10506:526;;;;1898:10149:3;10506:526:0;1898:10149:3;10506:526:0;;;;;;;;;1898:10149:3;11051:12:0;10506:526;;11051:12;:::i;10506:526::-;;1898:10149:3;10506:526:0;1898:10149:3;10506:526:0;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;11151:6;1898:10149;;:::i;:::-;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;11151:6;;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;8240:32;;:::i;:::-;1898:10149;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;3088:31;1898:10149;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;4279:40;1898:10149;;;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;;;4279:40;1898:10149;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;2091:42;1898:10149;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;3899:69;1898:10149;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;;;;3923:3;1898:10149;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;3899:69;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;-1:-1:-1;;11523:61:0;1898:10149:3;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;4065:69;1898:10149;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;4102:16;1898:10149;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;3062:20;1898:10149;;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;2181:5;1898:10149;;;;;;-1:-1:-1;;1898:10149:3;;;;12478:70:0;;:::i;:::-;1898:10149:3;6813:405:0;;;;;;;1898:10149:3;-1:-1:-1;;6813:405:0;1898:10149:3;;;;-1:-1:-1;;1898:10149:3;;;;9831:339:0;;;;1898:10149:3;9831:339:0;1898:10149:3;9831:339:0;;;;;;1898:10149:3;9831:339:0;;1898:10149:3;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;8411:27;-1:-1:-1;;8411:27:3;:::i;:::-;1898:10149;;;;;;;;;;;8391:55;;;1898:10149;8391:55;;1898:10149;;;;;;:::i;:::-;;;;;;8391:55;;;;;;;;1898:10149;8391:55;;;1898:10149;;;;;;;;;;;;;;;;;;;;;;8391:55;;1898:10149;8391:55;1898:10149;8391:55;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;;;;:::i;:::-;8391:55;;;;;;;;1898:10149;;;;;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;;;:::i;:::-;;1575:245:1;;;;;;;;;10445:10:3;;9021:22;9017:49;;1898:10149;9106:27;-1:-1:-1;;9106:27:3;:::i;:::-;1898:10149;;;;;9174:3;1898:10149;;;;;;;;9169:37;;1898:10149;;9169:37;;1898:10149;;;;;;;;;;:::i;:::-;;;;;;9169:37;;;;;;;;;;1898:10149;9169:37;;;1898:10149;;;;9220:9;;:25;9216:86;;1898:10149;;;;;;;;;9424:18;;1898:10149;9424:18;;1898:10149;9424:18;;;:::i;:::-;1898:10149;;;9480:63;1898:10149;;;;;;;9480:63;;1898:10149;;9480:63;;1898:10149;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9480:63;;;;;;;;;;1898:10149;;;9480:63;;;1898:10149;9553:53;;;;;:::i;:::-;1898:10149;;;;;9680:12;;1898:10149;;9622:151;1898:10149;;;;9719:27;;1898:10149;;;;;;;;;;;;;;;;;9622:151;1898:10149;9220:9;;1898:10149;9220:9;;1898:10149;;;;9220:9;9841:12;9837:73;;1898:10149;1883:75:1;;;1575:245;1883:75;1898:10149:3;;;;;;;;:::i;9837:73::-;9902:7;;;:::i;:::-;9837:73;;;;1898:10149;;;;;;;;;;;;9480:63;;;;;;;;;;;;;;;;:::i;:::-;;;1898:10149;;;9480:63;1898:10149;;;;;-1:-1:-1;1898:10149:3;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9553:53;1898:10149;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;9480:63;;;;;;;;;;9216:86;9254:48;;;1898:10149;9254:48;1898:10149;;9220:9;1898:10149;;;;9254:48;9169:37;;;1898:10149;9169:37;1898:10149;9169:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;9169:37;;;;;;;;9017:49;10445:10;;9017:49;;1575:245:1;;1898:10149:3;1575:245:1;1898:10149:3;1575:245:1;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;1990:42;1898:10149;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;11012:6;1898:10149;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;11012:6;:::i;1898:10149::-;;;-1:-1:-1;;1898:10149:3;;;;9239:383:0;;;;1898:10149:3;9239:383:0;7972:9;9132:15;1898:10149:3;9239:383:0;;;;;;1898:10149:3;9239:383:0;;1898:10149:3;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;;:::i;:::-;;10113:47;10149:10;1898:10149;;10113:47;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;-1:-1:-1;;;;;1898:10149:3;8411:27;1898:10149;;8411:27;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;3728:73;1898:10149;;;;;;:::i;:::-;12478:70:0;;:::i;:::-;1898:10149:3;;;:::i;:::-;3728:73;;:::i;1898:10149::-;;;;;;-1:-1:-1;;1898:10149:3;;;;;;:::i;:::-;;;12478:70:0;;:::i;:::-;-1:-1:-1;;;;;1898:10149:3;;;10697:16;;10693:53;;10760:11;;10756:45;;10853:6;;10875:22;10853:6;1898:10149;10853:6;;:::i;:::-;1898:10149;;;;;10875:22;1898:10149;10756:45;10780:21;;;1898:10149;10780:21;1898:10149;;10780:21;10693:53;10722:24;;;1898:10149;10722:24;1898:10149;;10722:24;1898:10149;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;1898:10149:3;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;:::o;:::-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;1898:10149:3;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;:::o;:::-;;;;-1:-1:-1;1898:10149:3;3955:12;1898:10149;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:::o;:::-;-1:-1:-1;3955:12:3;-1:-1:-1;1898:10149:3;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;-1:-1:-1;;1898:10149:3;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::i;:::-;;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;-1:-1:-1;1898:10149:3;;;;;;:::o;:::-;;;;;;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;-1:-1:-1;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;4691:1929;;1898:10149;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;;;;;;;;;4799:16;1898:10149;;4799:30;;;4795:67;;4876:14;;4872:48;;4951:14;;:::i;:::-;4992:21;;;;;;:45;;4975:62;5051:11;;5047:45;;5147:6;1898:10149;;;;;;;:::i;:::-;;;;;;;;;5115:255;;1898:10149;;5115:255;;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;-1:-1:-1;1898:10149:3;;;;:::i;:::-;;5115:255;;1898:10149;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;5115:255;;1898:10149;5103:267;5766:23;;;:::i;:::-;5803:36;;;;;4992:45;5799:68;;;4992:45;5881:11;;5877:45;;1898:10149;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;;6003:29;;;;;;1898:10149;;;;;;:::i;:::-;6003:29;;-1:-1:-1;;;;;1898:10149:3;6003:29;;;;;;;-1:-1:-1;6003:29:3;;;4992:45;1898:10149;;;6136:25;:58;;;;4992:45;6132:92;;1898:10149;;;;6238:40;;;;6234:109;;1898:10149;;6003:29;1898:10149;;;6405:34;;;6401:102;;1898:10149;;;;;;6589:24;1898:10149;;;4691:1929::o;6401:102::-;6448:55;;;-1:-1:-1;6448:55:3;6003:29;1898:10149;;;;-1:-1:-1;6448:55:3;6234:109;6287:56;;;-1:-1:-1;6287:56:3;6003:29;1898:10149;;;;-1:-1:-1;6287:56:3;6136:58;6165:24;;;;1898:10149;6165:29;6136:58;;6003:29;;;;;;;-1:-1:-1;6003:29:3;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;5799:68;5850:17;;;1898:10149;;-1:-1:-1;5799:68:3;;5803:36;5822:17;;;;;1898:10149;-1:-1:-1;5803:36:3;;;4992:45;;;;;4332:125;4419:5;1898:10149;;;-1:-1:-1;;;4403:47:3;;4444:4;4403:47;;;1898:10149;;;;;;4403:47;;1898:10149;;-1:-1:-1;;;;;1898:10149:3;4403:47;;;;;;;4419:5;4403:47;;;4396:54;4332:125;:::o;4403:47::-;;;1898:10149;4403:47;;1898:10149;4403:47;;;;;;1898:10149;4403:47;;;:::i;:::-;;;1898:10149;;;;;4332:125;:::o;4403:47::-;;;-1:-1:-1;4403:47:3;;1898:10149;;;;;;;;;;;;;;;;;:::i;7443:552::-;1898:10149;;-1:-1:-1;;;7617:32:3;;-1:-1:-1;;7617:32:3;;;1898:10149;10426:17;1898:10149;7617:32;1898:10149;7617:4;:32;;-1:-1:-1;;7617:32:3;;;7443:552;-1:-1:-1;7613:376:3;;7962:16;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;:::o;7613:376::-;1898:10149;;;;;-1:-1:-1;;;7705:37:3;;7617:32;7705:37;;1898:10149;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;:::i;:::-;-1:-1:-1;7617:32:3;1898:10149;;;7705:37;;;;-1:-1:-1;;7705:37:3;;;7613:376;-1:-1:-1;7701:230:3;;7900:16;;-1:-1:-1;7900:16:3;-1:-1:-1;7900:16:3;-1:-1:-1;7900:16:3;:::o;7701:230::-;1898:10149;7803:18;;1898:10149;7823:21;;;;1898:10149;;;;;7795:65::o;7705:37::-;;;;1898:10149;7705:37;1898:10149;7705:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;7705:37;;;;;;;;;7617:32;;;;;;-1:-1:-1;7617:32:3;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;;;:::i;:::-;;;;;7617:32;;;;7443:552;1898:10149;;;;;;7617:32;;;;;1898:10149;-1:-1:-1;7617:4:3;:32;:4;;:32;;-1:-1:-1;;7617:32:3;;;-1:-1:-1;7613:376:3;;7962:16;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;-1:-1:-1;7962:16:3;:::o;8797:1120::-;;;;1898:10149;;:::i;:::-;;;;:::i;:::-;;1575:245:1;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;9021:22;9017:49;;8797:1120;9106:27;;;:::i;:::-;1898:10149;;;;;9174:3;1898:10149;;;;;;;;9169:37;;1898:10149;9169:37;;;1898:10149;;;;;;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;;;9169:37;;;;;;;;;;-1:-1:-1;9169:37:3;;;8797:1120;1898:10149;;;9220:9;;:25;9216:86;;1898:10149;;;;;;-1:-1:-1;1898:10149:3;;9424:18;;1898:10149;9424:18;;1898:10149;9424:18;;;:::i;:::-;1898:10149;;;9480:63;1898:10149;;;;;;;9480:63;;1898:10149;9169:37;9480:63;;1898:10149;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9480:63;;;;;;;;;;-1:-1:-1;;;9480:63:3;;;8797:1120;9553:53;;;;;:::i;:::-;1898:10149;;;;;9680:12;;1898:10149;;9622:151;1898:10149;;;;9719:27;;1898:10149;;;;;;;;;;;;;;;;;9622:151;1898:10149;9220:9;;1898:10149;9220:9;;1898:10149;;;;9220:9;9841:12;9837:73;;8797:1120;1883:75:1;;;1575:245;1883:75;8973:28:3;8797:1120;:::o;9837:73::-;9902:7;;;:::i;:::-;9837:73;;;;9480:63;;;;;;;;;;;;;;;;:::i;:::-;;;1898:10149;;;9480:63;1898:10149;;;;;-1:-1:-1;1898:10149:3;;;;;;;;:::i;:::-;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;;9553:53;1898:10149;;;;;;;;;;;;;;;;:::i;:::-;9480:63;;;;;;;;;;9169:37;;;1898:10149;9169:37;1898:10149;9169:37;;;;;;;;:::i;:::-;;;1898:10149;;;;;;;;;;:::i;:::-;9169:37;;;;;;;;9017:49;9056:10;;-1:-1:-1;9017:49:3;;7292:355:0;-1:-1:-1;;7390:251:0;;;;;7292:355::o;7390:251::-;;;;;;;6934:721:2;7054:595;;;;;;;;;;;;;;;;6934:721;;:::o;7054:595::-;;;;;;;;;;;;;;;;;6934:721::o;7054:595::-;;;;;;;;;;;11483:562:3;;;;;;-1:-1:-1;;;;;1898:10149:3;;11679:20;;:42;;;;11483:562;11679:58;;;;11483:562;11675:117;;11697:1;1898:10149;;-1:-1:-1;;;;;;1898:10149:3;;;;;;;;-1:-1:-1;1898:10149:3;;-1:-1:-1;;;;;;1898:10149:3;-1:-1:-1;;;;;1898:10149:3;;;;;;;;;;-1:-1:-1;;;1898:10149:3;;;;;11872:36;1898:10149;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1898:10149:3;;;;;11918:28;1898:10149;;:::i;:::-;;;;;;11483:562;1898:10149;;;;;;;;;;;11962:76;1898:10149;;;;;11697:1;1898:10149;;;;;;11826:10;1898:10149;10426:17;;;1898:10149;11918:28;1898:10149;;;;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11962:76;;;11483:562::o;1898:10149::-;;;;;;;;;;;;;;11918:28;11697:1;1898:10149;-1:-1:-1;;;;;;;;;;;1898:10149:3;11697:1;1898:10149;;;;;;;;11962:76;1898:10149;;;;;;11826:10;1898:10149;;;;;;;;;;;11918:28;1898:10149;;;;;;;10426:17;;1898:10149;;11918:28;1898:10149;;;;;;;;;;;;;;;;;;;;;;;11826:10;1898:10149;;;;;;;;11918:28;11697:1;1898:10149;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;;;;;;;;;;;;11697:1;1898:10149;;11826:10;1898:10149;;;;-1:-1:-1;;;;;;;;;;;1898:10149:3;-1:-1:-1;1898:10149:3;;11675:117;11760:21;;;11697:1;11760:21;;11697:1;11760:21;11679:58;1898:10149;;;;11725:12;11679:58;;:42;-1:-1:-1;;;;;;1898:10149:3;;11703:18;11679:42;;11171:306;-1:-1:-1;;;;;1898:10149:3;;;11171:306;11260:16;;11256:53;;11323:11;;11319:45;;16484:754:2;;;;;;;;11274:1:3;16484:754:2;;11274:1:3;16484:754:2;;;;;;;;11274:1:3;16484:754:2;;;;;;11171:306:3;-1:-1:-1;11274:1:3;16484:754:2;;1898:10149:3;;;;;-1:-1:-1;;;;;1898:10149:3;;11438:32;;16484:754:2;;11438:32:3;11171:306::o;16484:754:2:-;;;;;;;;;;;;;;;11274:1:3;16484:754:2;;;;6626:434:3;1898:10149;;;;;:::i;:::-;-1:-1:-1;1898:10149:3;;-1:-1:-1;1898:10149:3;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;6805:3;1898:10149;;;;;;;;;;;;6800:29;;1898:10149;6800:29;;;1898:10149;;;;;;:::i;:::-;6800:29;;;;;1898:10149;;;6800:29;;;6626:434;-1:-1:-1;6796:258:3;;7013:30;;1898:10149;7013:30;;;:::o;6796:258::-;6805:3;;-1:-1:-1;6950:31:3;;-1:-1:-1;6950:31:3;:::o;6800:29::-;;;;;;;;;1898:10149;6800:29;;;;;;:::i;:::-;;;;-1:-1:-1;6800:29:3;;;6145:1089:0;1898:10149:3;;;;;6813:405:0;;;;;;-1:-1:-1;6813:405:0;;-1:-1:-1;;6813:405:0;6145:1089::o;20183:1707:2:-;;20318:1566;;-1:-1:-1;20318:1566:2;;;;;-1:-1:-1;20318:1566:2;;-1:-1:-1;20318:1566:2;;;;;;;;-1:-1:-1;20318:1566:2;;;;;;20183:1707;20318:1566;;-1:-1:-1;20318:1566:2;;20183:1707::o;20318:1566::-;;;;;;;;;;;;;;;-1:-1:-1;20318:1566:2;;;;-1:-1:-1;;;20318:1566:2;;;;;-1:-1:-1;20318:1566:2;;;;-1:-1:-1;20318:1566:2;;;-1:-1:-1;20318:1566:2;;;;;;;;;-1:-1:-1;20318:1566:2;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20318:1566:2;;;;20183:1707;;;20318:1566;;;;;;;;;;;;;;;;;;;;;;;;;;;20183:1707;20318:1566;;;;;;20183:1707::o;20318:1566::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;20318:1566:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"baseBurnReceiver()","signatureHash4":"0xda184924","signatureHash32":"0xda18492412d591474199ad39955a1e4772e6245eee9c280c5892a30ffcc88c98"},{"signature":"BASE_MAINNET_EID()","signatureHash4":"0x716cf553","signatureHash32":"0x716cf5532b13ecfa040cccf1ba3eeb7fc680bbd7be92df5777273830ebf72a0d"},{"signature":"bridgeToBaseBurnReceiver()","signatureHash4":"0x37bd27a1","signatureHash32":"0x37bd27a1634a71a93ac236206a91edf101b0c7c15e6807622089dfcd1f0ad602"},{"signature":"bridgeToBaseBurnReceiver(uint256)","signatureHash4":"0x1e6efe62","signatureHash32":"0x1e6efe624f9108a16b4747bf33f94c959f7fd54ee970fc7f12346d53536a48da"},{"signature":"bridgeToBaseBurnReceiver(uint256,address)","signatureHash4":"0xf35de557","signatureHash32":"0xf35de5577fd07414dd44d3d7eba5b819a0ff8fca038e7664a3df48abefab6c9d"},{"signature":"cancelOwnershipHandover()","signatureHash4":"0x54d1f13d","signatureHash32":"0x54d1f13d76f000aa202485e9c4b750a3fb26985ca34157c621201e1375bcbfac"},{"signature":"completeOwnershipHandover(address)","signatureHash4":"0xf04e283e","signatureHash32":"0xf04e283ea4b43821701876734697fc3e4a42281d51fee656e5c166b741e6afde"},{"signature":"DEFAULT_BASE_BURN_RECEIVER()","signatureHash4":"0x9e182477","signatureHash32":"0x9e1824773c391808b528dd0a9364f05c4e0c0f92edae843afbeed660b7272194"},{"signature":"dstEid()","signatureHash4":"0x734ff5f3","signatureHash32":"0x734ff5f307c6285e0cb6ea795a32978d14ed14e601ec919a7b36dfe8fa8bb616"},{"signature":"extraOptions()","signatureHash4":"0xa00642ca","signatureHash32":"0xa00642ca3df3d5d51513031ca3dfdca89263242ddcd90dadcb4513e477cb68ea"},{"signature":"IMD_TOKEN()","signatureHash4":"0x3465e045","signatureHash32":"0x3465e045fbe485c3a2903d82f2b19b6c58a9fd3b6d009c2863973e149fd5a4db"},{"signature":"minBridgeAmount()","signatureHash4":"0xc3c22475","signatureHash32":"0xc3c224751ed077a66c1cfbe71d37cc12dd2931ab120322dd00de72aecc9a6ede"},{"signature":"oft()","signatureHash4":"0x9b5215f6","signatureHash32":"0x9b5215f6eb172b86b3f36b65553701a8901affe2d6ed796a0f691269cf91368b"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"ownershipHandoverExpiresAt(address)","signatureHash4":"0xfee81cf4","signatureHash32":"0xfee81cf4fcd7f51611a3bf33478e3ef123da30b6dfa31a0b2a6d1192ef3c7e02"},{"signature":"previewBridge()","signatureHash4":"0xe102463d","signatureHash32":"0xe102463db11da1d786ae5f37921bec70809a58e0ab336342fc8129f94fac35ff"},{"signature":"previewBridge(uint256)","signatureHash4":"0x9f8902dd","signatureHash32":"0x9f8902dd76981ce44ba568db5fc514e6be4acacf304f45437cc688314d3e34d7"},{"signature":"quoteBridgeFee()","signatureHash4":"0x49914915","signatureHash32":"0x499149151e5b88833902da0965c82aac4d509f7b8266ebf5b5b30f24023c20d8"},{"signature":"quoteBridgeFee(uint256)","signatureHash4":"0x15b73c3d","signatureHash32":"0x15b73c3d3088f927a2a5591c3d840b2a328cefe9c9fd9b434830c2ca614a8308"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"requestOwnershipHandover()","signatureHash4":"0x25692962","signatureHash32":"0x25692962a9adba4272ff0251e0e6793c55bbf553e4476049416aa620e8960301"},{"signature":"rescueETH(address,uint256)","signatureHash4":"0x099a04e5","signatureHash32":"0x099a04e50705275f83d459948d26d43274b9994247a27699d4fb4eba4729bb6d"},{"signature":"rescueToken(address,address,uint256)","signatureHash4":"0xe5711e8b","signatureHash32":"0xe5711e8bd7e2b3b4cb43f684b0e2ab5cef039eae82f7d01328f2a49cd89c8d36"},{"signature":"rescueToken(address,uint256)","signatureHash4":"0x33f3d628","signatureHash32":"0x33f3d62869ef6b4feb317062f8d6f5e769661aa761cc1e9e818a46b633564824"},{"signature":"resolveSendParam(uint256)","signatureHash4":"0x45694e89","signatureHash32":"0x45694e8978277df8dde58b4a80a33110a7bb8ae5bfa020cdfcaabffeba69da9b"},{"signature":"setBaseBurnReceiver(address)","signatureHash4":"0x9578dc30","signatureHash32":"0x9578dc302675b5e15ce2027b35dbdf401a221b47be57afee3a32a2205973c6d7"},{"signature":"setBridgeConfig(address,address,uint32,address,bytes)","signatureHash4":"0x128530f1","signatureHash32":"0x128530f197df1d03d0424650867717b25f0b64ce026cedbfc50667fff56673bc"},{"signature":"setExtraOptions(bytes)","signatureHash4":"0x853b1422","signatureHash32":"0x853b14226b6530b164e374f36cd2723d95a2b50dcf051269e40f7044c3c24b2d"},{"signature":"setMinBridgeAmount(uint256)","signatureHash4":"0xd7d66e71","signatureHash32":"0xd7d66e712c3b5d36875a4b1b38fa336e4ef9eabdc13ee48d9c60936c92b0de47"},{"signature":"token()","signatureHash4":"0xfc0c546a","signatureHash32":"0xfc0c546a8dce9d6e9b97c086302918c9106d97a17809f6bcacfe02124763cb39"},{"signature":"tokenBalance()","signatureHash4":"0x9e1a4d19","signatureHash32":"0x9e1a4d196e55b59e25cf54f963f0978b85c89d94bc9ab3e8ba53ed9a3cd010e7"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"BridgeConfigUpdated(address,address,uint32,address,bytes)","signatureHash4":"0xcb878795","signatureHash32":"0xcb87879588845c69422b99d972c66222afa5f09e437a9952b50fb817df7a4883"},{"signature":"ETHRescued(address,uint256)","signatureHash4":"0xb3579861","signatureHash32":"0xb3579861130e4da8bb7b87c54d2d139937f23bcd6e4ebed9e75d0f78ab1cc118"},{"signature":"MinBridgeAmountUpdated(uint256)","signatureHash4":"0x6ba577ea","signatureHash32":"0x6ba577ea092916d439e41c77ec938aaec1b4d148e33152dc5bdf4af08bbf1fc8"},{"signature":"OwnershipHandoverCanceled(address)","signatureHash4":"0xfa7b8eab","signatureHash32":"0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92"},{"signature":"OwnershipHandoverRequested(address)","signatureHash4":"0xdbf36a10","signatureHash32":"0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"TokenRescued(address,address,uint256)","signatureHash4":"0x4143f7b5","signatureHash32":"0x4143f7b5cb6ea007914c32b8a3e64cebc051d7f493fa0755454da1e47701e125"},{"signature":"TokensBridgedForBurn(address,uint32,bytes32,uint256,uint256,bytes32)","signatureHash4":"0xf7f6980d","signatureHash32":"0xf7f6980d344862edf57320b659126becc0852f64b8347f913547cdb980fe3f25"}],"error":[{"signature":"AlreadyInitialized()","signatureHash4":"0x0dc149f0","signatureHash32":"0x0dc149f07762891dbcea3fe72770f3d63a1863fc54b2f084e8c59ec476996927"},{"signature":"BelowMinBridgeAmount(uint256,uint256)","signatureHash4":"0xa78210cf","signatureHash32":"0xa78210cff4076aef2fda09197252fe6340c999c992480d30763c6a8c5462d26b"},{"signature":"BelowOftMinimum(uint256,uint256)","signatureHash4":"0x6d6a6d66","signatureHash32":"0x6d6a6d6668d98daa34864d13f3caac4b866789c1996895465918f081d7276d86"},{"signature":"InsufficientMessageFee(uint256,uint256)","signatureHash4":"0x955eeb69","signatureHash32":"0x955eeb69e35b760465e4380adcb056a343549fc830518638e889e7b1033475ff"},{"signature":"InvalidBridgeAmount()","signatureHash4":"0xc7e9ed6d","signatureHash32":"0xc7e9ed6d1c7a159c010a44ba770d680ea3416aa23ac26de8bd02f08896711005"},{"signature":"InvalidBridgeConfig()","signatureHash4":"0x5110d791","signatureHash32":"0x5110d7915b8f2a7300fc1c388cc369a6e457aea104681cefee2c86d1f2b32833"},{"signature":"InvalidBridgeRecipient()","signatureHash4":"0xc888748f","signatureHash32":"0xc888748f1d38f793e96bd1d417b39039602399183a9e028eb3cb095bccea2f02"},{"signature":"NewOwnerIsZeroAddress()","signatureHash4":"0x7448fbae","signatureHash32":"0x7448fbae245b5163a637f61fac94c5376c3e155928452ce47ee52d8c1b99587a"},{"signature":"NoHandoverRequest()","signatureHash4":"0x6f5e8818","signatureHash32":"0x6f5e8818469c73d5be4a0d17c371cde64695907022629c1d064c895f98d466a6"},{"signature":"Reentrancy()","signatureHash4":"0xab143c06","signatureHash32":"0xab143c06c9772d69bbbc9f2fe74acd02f810e93b099f3d1dac8448ac9ae35991"},{"signature":"Unauthorized()","signatureHash4":"0x82b42900","signatureHash32":"0x82b4290015f7ec7256ca2a6247d3c2a89c4865c0e791456df195f40ad0a81367"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"1","address":"0xe29386719C155B6847aD5a4E97C6674f10ffc750"}